rclnodejs 1.6.0 → 1.8.0

package/lib/node.js

@@ -32,12 +32,20 @@ const {
   ParameterDescriptor,
 } = require('./parameter.js');
 const { isValidSerializationMode } = require('./message_serialization.js');
+const {
+  TypeValidationError,
+  RangeValidationError,
+  ValidationError,
+} = require('./errors.js');
 const ParameterService = require('./parameter_service.js');
+const ParameterClient = require('./parameter_client.js');
+const ParameterWatcher = require('./parameter_watcher.js');
 const Publisher = require('./publisher.js');
 const QoS = require('./qos.js');
 const Rates = require('./rate.js');
 const Service = require('./service.js');
 const Subscription = require('./subscription.js');
+const ObservableSubscription = require('./observable_subscription.js');
 const TimeSource = require('./time_source.js');
 const Timer = require('./timer.js');
 const TypeDescriptionService = require('./type_description_service.js');
@@ -74,8 +82,11 @@ class Node extends rclnodejs.ShadowNode {
   ) {
     super();
 
-    if (typeof nodeName !== 'string' || typeof namespace !== 'string') {
-      throw new TypeError('Invalid argument.');
+    if (typeof nodeName !== 'string') {
+      throw new TypeValidationError('nodeName', nodeName, 'string');
+    }
+    if (typeof namespace !== 'string') {
+      throw new TypeValidationError('namespace', namespace, 'string');
     }
 
     this._init(nodeName, namespace, options, context, args, useGlobalArguments);
@@ -92,7 +103,8 @@ class Node extends rclnodejs.ShadowNode {
       namespace,
       context.handle,
       args,
-      useGlobalArguments
+      useGlobalArguments,
+      options.rosoutQos
     );
     Object.defineProperty(this, 'handle', {
       configurable: false,
@@ -111,6 +123,8 @@ class Node extends rclnodejs.ShadowNode {
     this._events = [];
     this._actionClients = [];
     this._actionServers = [];
+    this._parameterClients = [];
+    this._parameterWatchers = [];
     this._rateTimerServer = null;
     this._parameterDescriptors = new Map();
     this._parameters = new Map();
@@ -120,6 +134,11 @@ class Node extends rclnodejs.ShadowNode {
     this._setParametersCallbacks = [];
     this._logger = new Logging(rclnodejs.getNodeLoggerName(this.handle));
     this._spinning = false;
+    this._enableRosout = options.enableRosout;
+
+    if (this._enableRosout) {
+      rclnodejs.initRosoutPublisherForNode(this.handle);
+    }
 
     this._parameterEventPublisher = this.createPublisher(
       PARAMETER_EVENT_MSG_TYPE,
@@ -133,8 +152,13 @@ class Node extends rclnodejs.ShadowNode {
     if (options.parameterOverrides.length > 0) {
       for (const parameter of options.parameterOverrides) {
         if ((!parameter) instanceof Parameter) {
-          throw new TypeError(
-            'Parameter-override must be an instance of Parameter.'
+          throw new TypeValidationError(
+            'parameterOverride',
+            parameter,
+            'Parameter instance',
+            {
+              nodeName: name,
+            }
           );
         }
         this._parameterOverrides.set(parameter.name, parameter);
@@ -514,7 +538,9 @@ class Node extends rclnodejs.ShadowNode {
       options !== undefined &&
       (options === null || typeof options !== 'object')
     ) {
-      throw new TypeError('Invalid argument of options');
+      throw new TypeValidationError('options', options, 'object', {
+        nodeName: this.name(),
+      });
     }
 
     if (options === undefined) {
@@ -536,8 +562,15 @@ class Node extends rclnodejs.ShadowNode {
     if (options.serializationMode === undefined) {
       options = Object.assign(options, { serializationMode: 'default' });
     } else if (!isValidSerializationMode(options.serializationMode)) {
-      throw new TypeError(
-        `Invalid serializationMode: ${options.serializationMode}. Valid modes are: 'default', 'plain', 'json'`
+      throw new ValidationError(
+        `Invalid serializationMode: ${options.serializationMode}. Valid modes are: 'default', 'plain', 'json'`,
+        {
+          code: 'INVALID_SERIALIZATION_MODE',
+          argumentName: 'serializationMode',
+          providedValue: options.serializationMode,
+          expectedType: "'default' | 'plain' | 'json'",
+          nodeName: this.name(),
+        }
       );
     }
 
@@ -558,8 +591,15 @@ class Node extends rclnodejs.ShadowNode {
       clock = arguments[3];
     }
 
-    if (typeof period !== 'bigint' || typeof callback !== 'function') {
-      throw new TypeError('Invalid argument');
+    if (typeof period !== 'bigint') {
+      throw new TypeValidationError('period', period, 'bigint', {
+        nodeName: this.name(),
+      });
+    }
+    if (typeof callback !== 'function') {
+      throw new TypeValidationError('callback', callback, 'function', {
+        nodeName: this.name(),
+      });
     }
 
     const timerClock = clock || this._clock;
@@ -584,13 +624,20 @@ class Node extends rclnodejs.ShadowNode {
    */
   async createRate(hz = 1) {
     if (typeof hz !== 'number') {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError('hz', hz, 'number', {
+        nodeName: this.name(),
+      });
     }
 
     const MAX_RATE_HZ_IN_MILLISECOND = 1000.0;
     if (hz <= 0.0 || hz > MAX_RATE_HZ_IN_MILLISECOND) {
-      throw new RangeError(
-        `Hz must be between 0.0 and ${MAX_RATE_HZ_IN_MILLISECOND}`
+      throw new RangeValidationError(
+        'hz',
+        hz,
+        `0.0 < hz <= ${MAX_RATE_HZ_IN_MILLISECOND}`,
+        {
+          nodeName: this.name(),
+        }
       );
     }
 
@@ -635,12 +682,32 @@ class Node extends rclnodejs.ShadowNode {
     }
     options = this._validateOptions(options);
 
+    if (typeof typeClass !== 'function') {
+      throw new TypeValidationError('typeClass', typeClass, 'function', {
+        nodeName: this.name(),
+        entityType: 'publisher',
+      });
+    }
+    if (typeof topic !== 'string') {
+      throw new TypeValidationError('topic', topic, 'string', {
+        nodeName: this.name(),
+        entityType: 'publisher',
+      });
+    }
     if (
-      typeof typeClass !== 'function' ||
-      typeof topic !== 'string' ||
-      (eventCallbacks && !(eventCallbacks instanceof PublisherEventCallbacks))
+      eventCallbacks &&
+      !(eventCallbacks instanceof PublisherEventCallbacks)
     ) {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError(
+        'eventCallbacks',
+        eventCallbacks,
+        'PublisherEventCallbacks',
+        {
+          nodeName: this.name(),
+          entityType: 'publisher',
+          entityName: topic,
+        }
+      );
     }
 
     let publisher = publisherClass.createPublisher(
@@ -704,14 +771,39 @@ class Node extends rclnodejs.ShadowNode {
     }
     options = this._validateOptions(options);
 
+    if (typeof typeClass !== 'function') {
+      throw new TypeValidationError('typeClass', typeClass, 'function', {
+        nodeName: this.name(),
+        entityType: 'subscription',
+      });
+    }
+    if (typeof topic !== 'string') {
+      throw new TypeValidationError('topic', topic, 'string', {
+        nodeName: this.name(),
+        entityType: 'subscription',
+      });
+    }
+    if (typeof callback !== 'function') {
+      throw new TypeValidationError('callback', callback, 'function', {
+        nodeName: this.name(),
+        entityType: 'subscription',
+        entityName: topic,
+      });
+    }
     if (
-      typeof typeClass !== 'function' ||
-      typeof topic !== 'string' ||
-      typeof callback !== 'function' ||
-      (eventCallbacks &&
-        !(eventCallbacks instanceof SubscriptionEventCallbacks))
+      eventCallbacks &&
+      !(eventCallbacks instanceof SubscriptionEventCallbacks)
     ) {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError(
+        'eventCallbacks',
+        eventCallbacks,
+        'SubscriptionEventCallbacks',
+        {
+          nodeName: this.name(),
+          entityType: 'subscription',
+          entityName: topic,
+        }
+      );
     }
 
     let subscription = Subscription.createSubscription(
@@ -729,6 +821,42 @@ class Node extends rclnodejs.ShadowNode {
     return subscription;
   }
 
+  /**
+   * Create a Subscription that returns an RxJS Observable.
+   * This allows using reactive programming patterns with ROS 2 messages.
+   *
+   * @param {function|string|object} typeClass - The ROS message class,
+   *      OR a string representing the message class, e.g. 'std_msgs/msg/String',
+   *      OR an object representing the message class, e.g. {package: 'std_msgs', type: 'msg', name: 'String'}
+   * @param {string} topic - The name of the topic.
+   * @param {object} [options] - The options argument used to parameterize the subscription.
+   * @param {boolean} [options.enableTypedArray=true] - The topic will use TypedArray if necessary.
+   * @param {QoS} [options.qos=QoS.profileDefault] - ROS Middleware "quality of service" settings.
+   * @param {boolean} [options.isRaw=false] - The topic is serialized when true.
+   * @param {string} [options.serializationMode='default'] - Controls message serialization format.
+   * @param {object} [options.contentFilter] - The content-filter (if supported by RMW).
+   * @param {SubscriptionEventCallbacks} [eventCallbacks] - The event callbacks for the subscription.
+   * @return {ObservableSubscription} - An ObservableSubscription with an RxJS Observable.
+   */
+  createObservableSubscription(typeClass, topic, options, eventCallbacks) {
+    let observableSubscription = null;
+
+    const subscription = this.createSubscription(
+      typeClass,
+      topic,
+      options,
+      (message) => {
+        if (observableSubscription) {
+          observableSubscription._emit(message);
+        }
+      },
+      eventCallbacks
+    );
+
+    observableSubscription = new ObservableSubscription(subscription);
+    return observableSubscription;
+  }
+
   /**
    * Create a Client.
    * @param {function|string|object} typeClass - The ROS message class,
@@ -746,8 +874,17 @@ class Node extends rclnodejs.ShadowNode {
     }
     options = this._validateOptions(options);
 
-    if (typeof typeClass !== 'function' || typeof serviceName !== 'string') {
-      throw new TypeError('Invalid argument');
+    if (typeof typeClass !== 'function') {
+      throw new TypeValidationError('typeClass', typeClass, 'function', {
+        nodeName: this.name(),
+        entityType: 'client',
+      });
+    }
+    if (typeof serviceName !== 'string') {
+      throw new TypeValidationError('serviceName', serviceName, 'string', {
+        nodeName: this.name(),
+        entityType: 'client',
+      });
     }
 
     let client = Client.createClient(
@@ -801,12 +938,24 @@ class Node extends rclnodejs.ShadowNode {
     }
     options = this._validateOptions(options);
 
-    if (
-      typeof typeClass !== 'function' ||
-      typeof serviceName !== 'string' ||
-      typeof callback !== 'function'
-    ) {
-      throw new TypeError('Invalid argument');
+    if (typeof typeClass !== 'function') {
+      throw new TypeValidationError('typeClass', typeClass, 'function', {
+        nodeName: this.name(),
+        entityType: 'service',
+      });
+    }
+    if (typeof serviceName !== 'string') {
+      throw new TypeValidationError('serviceName', serviceName, 'string', {
+        nodeName: this.name(),
+        entityType: 'service',
+      });
+    }
+    if (typeof callback !== 'function') {
+      throw new TypeValidationError('callback', callback, 'function', {
+        nodeName: this.name(),
+        entityType: 'service',
+        entityName: serviceName,
+      });
     }
 
     let service = Service.createService(
@@ -823,6 +972,52 @@ class Node extends rclnodejs.ShadowNode {
     return service;
   }
 
+  /**
+   * Create a ParameterClient for accessing parameters on a remote node.
+   * @param {string} remoteNodeName - The name of the remote node whose parameters to access.
+   * @param {object} [options] - Options for parameter client.
+   * @param {number} [options.timeout=5000] - Default timeout in milliseconds for service calls.
+   * @return {ParameterClient} - An instance of ParameterClient.
+   */
+  createParameterClient(remoteNodeName, options = {}) {
+    if (typeof remoteNodeName !== 'string' || remoteNodeName.trim() === '') {
+      throw new TypeError('Remote node name must be a non-empty string');
+    }
+
+    const parameterClient = new ParameterClient(this, remoteNodeName, options);
+    debug(
+      'Finish creating parameter client for remote node = %s.',
+      remoteNodeName
+    );
+    this._parameterClients.push(parameterClient);
+
+    return parameterClient;
+  }
+
+  /**
+   * Create a ParameterWatcher for watching parameter changes on a remote node.
+   * @param {string} remoteNodeName - The name of the remote node whose parameters to watch.
+   * @param {string[]} parameterNames - Array of parameter names to watch.
+   * @param {object} [options] - Options for parameter watcher.
+   * @param {number} [options.timeout=5000] - Default timeout in milliseconds for service calls.
+   * @return {ParameterWatcher} - An instance of ParameterWatcher.
+   */
+  createParameterWatcher(remoteNodeName, parameterNames, options = {}) {
+    const watcher = new ParameterWatcher(
+      this,
+      remoteNodeName,
+      parameterNames,
+      options
+    );
+    debug(
+      'Finish creating parameter watcher for remote node = %s.',
+      remoteNodeName
+    );
+    this._parameterWatchers.push(watcher);
+
+    return watcher;
+  }
+
   /**
    * Create a guard condition.
    * @param {Function} callback - The callback to be called when the guard condition is triggered.
@@ -830,7 +1025,10 @@ class Node extends rclnodejs.ShadowNode {
    */
   createGuardCondition(callback) {
     if (typeof callback !== 'function') {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError('callback', callback, 'function', {
+        nodeName: this.name(),
+        entityType: 'guard_condition',
+      });
     }
 
     let guard = GuardCondition.createGuardCondition(callback, this.context);
@@ -856,8 +1054,16 @@ class Node extends rclnodejs.ShadowNode {
     this._actionClients.forEach((actionClient) => actionClient.destroy());
     this._actionServers.forEach((actionServer) => actionServer.destroy());
 
+    this._parameterClients.forEach((paramClient) => paramClient.destroy());
+    this._parameterWatchers.forEach((watcher) => watcher.destroy());
+
     this.context.onNodeDestroyed(this);
 
+    if (this._enableRosout) {
+      rclnodejs.finiRosoutPublisherForNode(this.handle);
+      this._enableRosout = false;
+    }
+
     this.handle.release();
     this._clock = null;
     this._timers = [];
@@ -868,6 +1074,8 @@ class Node extends rclnodejs.ShadowNode {
     this._guards = [];
     this._actionClients = [];
     this._actionServers = [];
+    this._parameterClients = [];
+    this._parameterWatchers = [];
 
     if (this._rateTimerServer) {
       this._rateTimerServer.shutdown();
@@ -882,7 +1090,14 @@ class Node extends rclnodejs.ShadowNode {
    */
   destroyPublisher(publisher) {
     if (!(publisher instanceof Publisher)) {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError(
+        'publisher',
+        publisher,
+        'Publisher instance',
+        {
+          nodeName: this.name(),
+        }
+      );
     }
     if (publisher.events) {
       publisher.events.forEach((event) => {
@@ -900,7 +1115,14 @@ class Node extends rclnodejs.ShadowNode {
    */
   destroySubscription(subscription) {
     if (!(subscription instanceof Subscription)) {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError(
+        'subscription',
+        subscription,
+        'Subscription instance',
+        {
+          nodeName: this.name(),
+        }
+      );
     }
     if (subscription.events) {
       subscription.events.forEach((event) => {
@@ -919,7 +1141,9 @@ class Node extends rclnodejs.ShadowNode {
    */
   destroyClient(client) {
     if (!(client instanceof Client)) {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError('client', client, 'Client instance', {
+        nodeName: this.name(),
+      });
     }
     this._destroyEntity(client, this._clients);
   }
@@ -931,11 +1155,39 @@ class Node extends rclnodejs.ShadowNode {
    */
   destroyService(service) {
     if (!(service instanceof Service)) {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError('service', service, 'Service instance', {
+        nodeName: this.name(),
+      });
     }
     this._destroyEntity(service, this._services);
   }
 
+  /**
+   * Destroy a ParameterClient.
+   * @param {ParameterClient} parameterClient - The ParameterClient to be destroyed.
+   * @return {undefined}
+   */
+  destroyParameterClient(parameterClient) {
+    if (!(parameterClient instanceof ParameterClient)) {
+      throw new TypeError('Invalid argument');
+    }
+    this._removeEntityFromArray(parameterClient, this._parameterClients);
+    parameterClient.destroy();
+  }
+
+  /**
+   * Destroy a ParameterWatcher.
+   * @param {ParameterWatcher} watcher - The ParameterWatcher to be destroyed.
+   * @return {undefined}
+   */
+  destroyParameterWatcher(watcher) {
+    if (!(watcher instanceof ParameterWatcher)) {
+      throw new TypeError('Invalid argument');
+    }
+    this._removeEntityFromArray(watcher, this._parameterWatchers);
+    watcher.destroy();
+  }
+
   /**
    * Destroy a Timer.
    * @param {Timer} timer - The Timer to be destroyed.
@@ -943,7 +1195,9 @@ class Node extends rclnodejs.ShadowNode {
    */
   destroyTimer(timer) {
     if (!(timer instanceof Timer)) {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError('timer', timer, 'Timer instance', {
+        nodeName: this.name(),
+      });
     }
     this._destroyEntity(timer, this._timers);
   }
@@ -955,7 +1209,9 @@ class Node extends rclnodejs.ShadowNode {
    */
   destroyGuardCondition(guard) {
     if (!(guard instanceof GuardCondition)) {
-      throw new TypeError('Invalid argument');
+      throw new TypeValidationError('guard', guard, 'GuardCondition instance', {
+        nodeName: this.name(),
+      });
     }
     this._destroyEntity(guard, this._guards);
   }
@@ -1002,7 +1258,7 @@ class Node extends rclnodejs.ShadowNode {
 
   /**
    * Get the current time using the node's clock.
-   * @returns {Time} - The current time.
+   * @returns {Timer} - The current time.
    */
   now() {
     return this.getClock().now();
@@ -1141,6 +1397,74 @@ class Node extends rclnodejs.ShadowNode {
     );
   }
 
+  /**
+   * Return a list of clients on a given service.
+   *
+   * The returned parameter is a list of ServiceEndpointInfo objects, where each will contain
+   * the node name, node namespace, service type, service endpoint's GID, and its QoS profile.
+   *
+   * When the `no_mangle` parameter is `true`, the provided `service` should be a valid
+   * service name for the middleware (useful when combining ROS with native middleware (e.g. DDS)
+   * apps).  When the `no_mangle` parameter is `false`, the provided `service` should
+   * follow ROS service name conventions.
+   *
+   * `service` may be a relative, private, or fully qualified service name.
+   *  A relative or private service will be expanded using this node's namespace and name.
+   *  The queried `service` is not remapped.
+   *
+   * @param {string} service - The service on which to find the clients.
+   * @param {boolean} [noDemangle=false] - If `true`, `service` needs to be a valid middleware service
+   *                               name, otherwise it should be a valid ROS service name. Defaults to `false`.
+   * @returns {Array} - list of clients
+   */
+  getClientsInfoByService(service, noDemangle = false) {
+    if (DistroUtils.getDistroId() < DistroUtils.DistroId.ROLLING) {
+      console.warn(
+        'getClientsInfoByService is not supported by this version of ROS 2'
+      );
+      return null;
+    }
+    return rclnodejs.getClientsInfoByService(
+      this.handle,
+      this._getValidatedServiceName(service, noDemangle),
+      noDemangle
+    );
+  }
+
+  /**
+   * Return a list of servers on a given service.
+   *
+   * The returned parameter is a list of ServiceEndpointInfo objects, where each will contain
+   * the node name, node namespace, service type, service endpoint's GID, and its QoS profile.
+   *
+   * When the `no_mangle` parameter is `true`, the provided `service` should be a valid
+   * service name for the middleware (useful when combining ROS with native middleware (e.g. DDS)
+   * apps).  When the `no_mangle` parameter is `false`, the provided `service` should
+   * follow ROS service name conventions.
+   *
+   * `service` may be a relative, private, or fully qualified service name.
+   *  A relative or private service will be expanded using this node's namespace and name.
+   *  The queried `service` is not remapped.
+   *
+   * @param {string} service - The service on which to find the servers.
+   * @param {boolean} [noDemangle=false] - If `true`, `service` needs to be a valid middleware service
+   *                               name, otherwise it should be a valid ROS service name. Defaults to `false`.
+   * @returns {Array} - list of servers
+   */
+  getServersInfoByService(service, noDemangle = false) {
+    if (DistroUtils.getDistroId() < DistroUtils.DistroId.ROLLING) {
+      console.warn(
+        'getServersInfoByService is not supported by this version of ROS 2'
+      );
+      return null;
+    }
+    return rclnodejs.getServersInfoByService(
+      this.handle,
+      this._getValidatedServiceName(service, noDemangle),
+      noDemangle
+    );
+  }
+
   /**
    * Get the list of nodes discovered by the provided node.
    * @return {Array<string>} - An array of the names.
@@ -1247,14 +1571,14 @@ class Node extends rclnodejs.ShadowNode {
    *
    * @param {Parameter} parameter - Parameter to declare.
    * @param {ParameterDescriptor} [descriptor] - Optional descriptor for parameter.
-   * @param {boolean} [ignoreOveride] - When true disregard any parameter-override that may be present.
+   * @param {boolean} [ignoreOverride] - When true disregard any parameter-override that may be present.
    * @return {Parameter} - The newly declared parameter.
    */
-  declareParameter(parameter, descriptor, ignoreOveride = false) {
+  declareParameter(parameter, descriptor, ignoreOverride = false) {
     const parameters = this.declareParameters(
       [parameter],
       descriptor ? [descriptor] : [],
-      ignoreOveride
+      ignoreOverride
     );
     return parameters.length == 1 ? parameters[0] : null;
   }
@@ -1295,16 +1619,25 @@ class Node extends rclnodejs.ShadowNode {
    */
   declareParameters(parameters, descriptors = [], ignoreOverrides = false) {
     if (!Array.isArray(parameters)) {
-      throw new TypeError('Invalid parameter: expected array of Parameter');
+      throw new TypeValidationError('parameters', parameters, 'Array', {
+        nodeName: this.name(),
+      });
     }
     if (!Array.isArray(descriptors)) {
-      throw new TypeError(
-        'Invalid parameters: expected array of ParameterDescriptor'
-      );
+      throw new TypeValidationError('descriptors', descriptors, 'Array', {
+        nodeName: this.name(),
+      });
     }
     if (descriptors.length > 0 && parameters.length !== descriptors.length) {
-      throw new TypeError(
-        'Each parameter must have a cooresponding ParameterDescriptor'
+      throw new ValidationError(
+        'Each parameter must have a corresponding ParameterDescriptor',
+        {
+          code: 'PARAMETER_DESCRIPTOR_MISMATCH',
+          argumentName: 'descriptors',
+          providedValue: descriptors.length,
+          expectedType: `Array with length ${parameters.length}`,
+          nodeName: this.name(),
+        }
       );
     }
 
@@ -1744,7 +2077,9 @@ class Node extends rclnodejs.ShadowNode {
    */
   resolveTopicName(topicName, onlyExpand = false) {
     if (typeof topicName !== 'string') {
-      throw new TypeError('Invalid argument: expected string');
+      throw new TypeValidationError('topicName', topicName, 'string', {
+        nodeName: this.name(),
+      });
     }
     return rclnodejs.resolveName(
       this.handle,
@@ -1762,7 +2097,9 @@ class Node extends rclnodejs.ShadowNode {
    */
   resolveServiceName(service, onlyExpand = false) {
     if (typeof service !== 'string') {
-      throw new TypeError('Invalid argument: expected string');
+      throw new TypeValidationError('service', service, 'string', {
+        nodeName: this.name(),
+      });
     }
     return rclnodejs.resolveName(
       this.handle,
@@ -1921,6 +2258,22 @@ class Node extends rclnodejs.ShadowNode {
     validateFullTopicName(fqTopicName);
     return rclnodejs.remapTopicName(this.handle, fqTopicName);
   }
+
+  _getValidatedServiceName(serviceName, noDemangle) {
+    if (typeof serviceName !== 'string') {
+      throw new TypeValidationError('serviceName', serviceName, 'string', {
+        nodeName: this.name(),
+      });
+    }
+
+    if (noDemangle) {
+      return serviceName;
+    }
+
+    const resolvedServiceName = this.resolveServiceName(serviceName);
+    rclnodejs.validateTopicName(resolvedServiceName);
+    return resolvedServiceName;
+  }
 }
 
 /**