rclnodejs 1.8.2 → 1.8.3

package/index.js

@@ -85,7 +85,7 @@ async function getCurrentGeneratorVersion() {
   const jsonFilePath = path.join(generator.generatedRoot, 'generator.json');
 
   return new Promise((resolve, reject) => {
-    fs.open(jsonFilePath, 'r', (err) => {
+    fs.readFile(jsonFilePath, 'utf8', (err, data) => {
       if (err) {
         if (err.code === 'ENOENT') {
           resolve(null);
@@ -93,13 +93,11 @@ async function getCurrentGeneratorVersion() {
           reject(err);
         }
       } else {
-        fs.readFile(jsonFilePath, 'utf8', (err, data) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve(JSON.parse(data).version);
-          }
-        });
+        try {
+          resolve(JSON.parse(data).version);
+        } catch (parseErr) {
+          reject(parseErr);
+        }
       }
     });
   });
@@ -389,23 +387,35 @@ let rcl = {
 
     rclnodejs.init(context.handle, argv, context._domainId);
 
-    if (_rosVersionChecked) {
-      // no further processing required
-      return;
-    }
+    try {
+      if (_rosVersionChecked) {
+        // no further processing required
+        return;
+      }
 
-    const version = await getCurrentGeneratorVersion();
-    const forced =
-      version === null || compareVersions(version, generator.version(), '<');
-    if (forced) {
-      debug(
-        'The generator will begin to create JavaScript code from ROS IDL files...'
-      );
-    }
+      const version = await getCurrentGeneratorVersion();
+      const forced =
+        version === null || compareVersions(version, generator.version(), '<');
+      if (forced) {
+        debug(
+          'The generator will begin to create JavaScript code from ROS IDL files...'
+        );
+      }
 
-    await generator.generateAll(forced);
-    // TODO determine if tsd generateAll() should be here
-    _rosVersionChecked = true;
+      await generator.generateAll(forced);
+      // TODO determine if tsd generateAll() should be here
+      _rosVersionChecked = true;
+    } catch (error) {
+      try {
+        context.tryShutdown();
+      } catch (shutdownError) {
+        const initError =
+          error instanceof Error ? error : new Error(String(error));
+        initError.message += ` (rollback also failed: ${shutdownError.message})`;
+        throw initError;
+      }
+      throw error;
+    }
   },
 
   /**

package/lib/action/client.js

@@ -126,6 +126,12 @@ class ActionClient extends Entity {
         }
 
         this._goalHandles.set(uuid, goalHandle);
+      } else {
+        // Clean up feedback callback for rejected goals
+        let uuid = ActionUuid.fromMessage(
+          this._sequenceNumberGoalIdMap.get(sequence)
+        ).toString();
+        this._feedbackCallbacks.delete(uuid);
       }
 
       this._pendingGoalRequests.get(sequence).setResult(goalHandle);

package/lib/action/server.js

@@ -437,10 +437,8 @@ class ActionServer extends Entity {
 
   _executeExpiredGoals(result, count) {
     for (let i = 0; i < count; i++) {
-      const goal = result.data[i];
-
       const goalInfo = new ActionInterfaces.GoalInfo();
-      goalInfo.deserialize(goal.refObject);
+      goalInfo.deserialize(result._refArray[i]);
 
       let uuid = ActionUuid.fromBytes(goalInfo.goal_id.uuid).toString();
       this._goalHandles.delete(uuid);

package/lib/distro.js

@@ -65,7 +65,8 @@ const DistroUtils = {
       return process.env.ROS_DISTRO;
     }
 
-    return [...DistroNameIdMap].find(([, val]) => val == distroId)[0];
+    const result = [...DistroNameIdMap].find(([, val]) => val == distroId);
+    return result ? result[0] : undefined;
   },
 
   getKnownDistroNames: function () {

package/lib/lifecycle_publisher.js

@@ -30,7 +30,7 @@ class LifecyclePublisher extends Publisher {
     super(handle, typeClass, /*topic=*/ '', options);
 
     this._enabled = false;
-    this._loggger = Logging.getLogger('LifecyclePublisher');
+    this._logger = Logging.getLogger('LifecyclePublisher');
   }
 
   /**
@@ -42,7 +42,7 @@ class LifecyclePublisher extends Publisher {
    */
   publish(message) {
     if (!this._enabled) {
-      this._loggger.warn(
+      this._logger.warn(
         `Trying to publish message on the topic ${this.topic}, but the publisher is not activated`
       );
 

package/lib/node.js

@@ -97,7 +97,30 @@ class Node extends rclnodejs.ShadowNode {
     );
   }
 
+  static _normalizeOptions(options) {
+    if (options instanceof NodeOptions) {
+      return options;
+    }
+    const defaults = NodeOptions.defaultOptions;
+    return {
+      startParameterServices:
+        options.startParameterServices ?? defaults.startParameterServices,
+      parameterOverrides:
+        options.parameterOverrides ?? defaults.parameterOverrides,
+      automaticallyDeclareParametersFromOverrides:
+        options.automaticallyDeclareParametersFromOverrides ??
+        defaults.automaticallyDeclareParametersFromOverrides,
+      startTypeDescriptionService:
+        options.startTypeDescriptionService ??
+        defaults.startTypeDescriptionService,
+      enableRosout: options.enableRosout ?? defaults.enableRosout,
+      rosoutQos: options.rosoutQos ?? defaults.rosoutQos,
+    };
+  }
+
   _init(name, namespace, options, context, args, useGlobalArguments) {
+    options = Node._normalizeOptions(options);
+
     this.handle = rclnodejs.createNode(
       name,
       namespace,
@@ -151,7 +174,7 @@ class Node extends rclnodejs.ShadowNode {
     // override cli parameterOverrides with those specified in options
     if (options.parameterOverrides.length > 0) {
       for (const parameter of options.parameterOverrides) {
-        if ((!parameter) instanceof Parameter) {
+        if (!(parameter instanceof Parameter)) {
           throw new TypeValidationError(
             'parameterOverride',
             parameter,
@@ -425,17 +448,20 @@ class Node extends rclnodejs.ShadowNode {
       }
 
       if (properties.isGoalExpired) {
-        let GoalInfoArray = ActionInterfaces.GoalInfo.ArrayType;
-        let message = new GoalInfoArray(actionServer._goalHandles.size);
-        let count = rclnodejs.actionExpireGoals(
-          actionServer.handle,
-          actionServer._goalHandles.size,
-          message._refArray.buffer
-        );
-        if (count > 0) {
-          actionServer.processGoalExpired(message, count);
+        let numGoals = actionServer._goalHandles.size;
+        if (numGoals > 0) {
+          let GoalInfoArray = ActionInterfaces.GoalInfo.ArrayType;
+          let message = new GoalInfoArray(numGoals);
+          let count = rclnodejs.actionExpireGoals(
+            actionServer.handle,
+            numGoals,
+            message._refArray.buffer
+          );
+          if (count > 0) {
+            actionServer.processGoalExpired(message, count);
+          }
+          GoalInfoArray.freeArray(message);
         }
-        GoalInfoArray.freeArray(message);
       }
     }
 

package/lib/parameter.js

@@ -864,9 +864,8 @@ function parameterTypeFromValue(value) {
 function validType(parameterType) {
   let result =
     typeof parameterType === 'number' &&
-    ParameterType.PARAMETER_NOT_SET <=
-      parameterType <=
-      ParameterType.PARAMETER_STRING_ARRAY;
+    parameterType >= ParameterType.PARAMETER_NOT_SET &&
+    parameterType <= ParameterType.PARAMETER_STRING_ARRAY;
 
   return result;
 }
@@ -923,14 +922,11 @@ function _validArray(values, type) {
     arrayElementType = ParameterType.PARAMETER_BOOL;
   } else if (type === ParameterType.PARAMETER_BYTE_ARRAY) {
     arrayElementType = PARAMETER_BYTE;
-  }
-  if (type === ParameterType.PARAMETER_INTEGER_ARRAY) {
+  } else if (type === ParameterType.PARAMETER_INTEGER_ARRAY) {
     arrayElementType = ParameterType.PARAMETER_INTEGER;
-  }
-  if (type === ParameterType.PARAMETER_DOUBLE_ARRAY) {
+  } else if (type === ParameterType.PARAMETER_DOUBLE_ARRAY) {
     arrayElementType = ParameterType.PARAMETER_DOUBLE;
-  }
-  if (type === ParameterType.PARAMETER_STRING_ARRAY) {
+  } else if (type === ParameterType.PARAMETER_STRING_ARRAY) {
     arrayElementType = ParameterType.PARAMETER_STRING;
   }
 

package/lib/service.js

@@ -17,6 +17,7 @@
 const rclnodejs = require('./native_loader.js');
 const DistroUtils = require('./distro.js');
 const Entity = require('./entity.js');
+const Logging = require('./logging.js');
 const debug = require('debug')('rclnodejs:service');
 
 /**
@@ -75,8 +76,8 @@ class Service extends Entity {
 
     const plainObj = request.toPlainObject(this.typedArrayEnabled);
     const response = new Response(this, headerHandle);
-    Promise.resolve(this._callback(plainObj, response)).then(
-      (responseToReturn) => {
+    Promise.resolve(this._callback(plainObj, response))
+      .then((responseToReturn) => {
         if (!response.sent && responseToReturn) {
           responseToReturn = new this._typeClass.Response(responseToReturn);
           const rawResponse = responseToReturn.serialize();
@@ -86,8 +87,11 @@ class Service extends Entity {
         debug(
           `Service has processed the ${this._serviceName} request and sent the response.`
         );
-      }
-    );
+      })
+      .catch((error) => {
+        const logger = Logging.getLogger('rclnodejs');
+        logger.error(`Error processing ${this._serviceName} request: ${error}`);
+      });
   }
 
   static createService(nodeHandle, serviceName, typeClass, options, callback) {

package/lib/time_source.js

@@ -45,26 +45,6 @@ class TimeSource {
     }
   }
 
-  get isRosTimeActive() {
-    return this._isRosTimeActive;
-  }
-
-  set isRosTimeActive(enabled) {
-    if (this.isRosTimeActive === enabled) return;
-
-    this._isRosTimeActive = enabled;
-    for (const clock in this._associatedClocks) {
-      clock.isRosTimeActive = enabled;
-    }
-
-    if (enabled) {
-      this._subscribeToClockTopic();
-    } else if (this._node && this._clockSubscription) {
-      this._node.destroySubscription(this._clockSubscription);
-      this._node._clockSubscription = null;
-    }
-  }
-
   /**
    * Return status that whether the ROS time is active.
    * @name TimeSource#get:isRosTimeActive
@@ -93,6 +73,9 @@ class TimeSource {
     });
     if (enabled) {
       this._subscribeToClockTopic();
+    } else if (this._node && this._clockSubscription) {
+      this._node.destroySubscription(this._clockSubscription);
+      this._clockSubscription = undefined;
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rclnodejs",
-  "version": "1.8.2",
+  "version": "1.8.3",
   "description": "ROS2.0 JavaScript client with Node.js",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -65,7 +65,7 @@
     "lint-staged": "^16.2.0",
     "mocha": "^11.0.2",
     "node-gyp": "^12.1.0",
-    "nyc": "^17.1.0",
+    "nyc": "^18.0.0",
     "prebuildify": "^6.0.1",
     "rimraf": "^6.0.1",
     "sinon": "^21.0.0",

package/rosidl_gen/generate_worker.js

@@ -12,14 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-const fse = require('../lib/utils.js');
 const generateJSStructFromIDL = require('./idl_generator.js');
 const packages = require('./packages.js');
 const path = require('path');
-const idlConvertor = require('../rosidl_convertor/idl_convertor.js');
 
 const generatedRoot = path.join(__dirname, '../generated/');
-const idlPath = path.join(generatedRoot, 'share');
 const useIDL = !!process.argv.find((arg) => arg === '--idl');
 
 // Get target path from environment variable instead of workerData
@@ -32,17 +29,10 @@ async function generateInPath(targetPath) {
       (await packages.findPackagesInDirectory(targetPath)).values()
     );
   } else {
+    // Direct IDL parsing: pass .idl files to the generator which uses
+    // rosidl_parser to parse them directly (no .msg/.srv/.action conversion).
     const idlPkgs = await packages.findPackagesInDirectory(targetPath, useIDL);
-    await fse.ensureDir(idlPath);
-    const promises = [];
-    idlPkgs.forEach((pkg) => {
-      pkg.idls.forEach((idl) => {
-        promises.push(idlConvertor(idl.pkgName, idl.filePath, idlPath));
-      });
-    });
-    await Promise.all(promises);
-    const pkgsFromIdl = await packages.findPackagesInDirectory(idlPath, false);
-    pkgsInfo = Array.from(pkgsFromIdl.values());
+    pkgsInfo = Array.from(idlPkgs.values());
   }
 
   await Promise.all(

package/rosidl_gen/idl_generator.js

@@ -305,7 +305,217 @@ async function generateJSStructFromIDL(pkg, dir) {
   pkg.actions.forEach((actionInfo) => {
     results.push(generateActionJSStruct(actionInfo, dir));
   });
+
+  // Handle .idl files directly (parsed via rosidl_parser, no .msg conversion)
+  if (pkg.idls) {
+    pkg.idls.forEach((idlInfo) => {
+      results.push(generateJSStructFromIdlFile(idlInfo, dir));
+    });
+  }
+
   await Promise.all(results);
 }
 
+/**
+ * Parse an .idl file directly and generate the appropriate JS struct.
+ * This uses rosidl_parser to parse the IDL and produces the same JSON
+ * spec format, so the same templates can be used.
+ */
+async function generateJSStructFromIdlFile(idlInfo, dir) {
+  const result = await parser.parseIdlFile(idlInfo.filePath);
+  const { type, spec } = result;
+
+  if (type === 'message') {
+    await generateMessageJSStructFromSpec(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: idlInfo.interfaceName,
+      },
+      dir,
+      spec
+    );
+  } else if (type === 'service') {
+    // Generate request and response message JS structs
+    const requestMsg = generateMessageJSStructFromSpec(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: `${idlInfo.interfaceName}_Request`,
+      },
+      dir,
+      spec.request
+    );
+
+    const responseMsg = generateMessageJSStructFromSpec(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: `${idlInfo.interfaceName}_Response`,
+      },
+      dir,
+      spec.response
+    );
+
+    // Generate service JS struct
+    const serviceInfo = {
+      pkgName: idlInfo.pkgName,
+      subFolder: idlInfo.subFolder,
+      interfaceName: idlInfo.interfaceName,
+    };
+    const srv = generateServiceJSStruct(
+      serviceInfo,
+      dir,
+      /*isActionService=*/ false
+    );
+
+    await Promise.all([requestMsg, responseMsg, srv]);
+  } else if (type === 'action') {
+    // Generate goal, result, feedback message JS structs
+    const goalMsg = generateMessageJSStructFromSpec(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: `${idlInfo.interfaceName}_Goal`,
+      },
+      dir,
+      spec.goal
+    );
+
+    const resultMsg = generateMessageJSStructFromSpec(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: `${idlInfo.interfaceName}_Result`,
+      },
+      dir,
+      spec.result
+    );
+
+    const feedbackMsg = generateMessageJSStructFromSpec(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: `${idlInfo.interfaceName}_Feedback`,
+      },
+      dir,
+      spec.feedback
+    );
+
+    // Generate derived action messages (SendGoal, GetResult, FeedbackMessage)
+    const sendGoalRequestSpec = actionMsgs.createSendGoalRequestSpec(
+      idlInfo.pkgName,
+      idlInfo.interfaceName
+    );
+    const sendGoalRequestMsg = generateMessageJSStructFromSpec(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: `${idlInfo.interfaceName}_SendGoal_Request`,
+      },
+      dir,
+      sendGoalRequestSpec
+    );
+
+    const sendGoalResponseSpec = actionMsgs.createSendGoalResponseSpec(
+      idlInfo.pkgName,
+      idlInfo.interfaceName
+    );
+    const sendGoalResponseMsg = generateMessageJSStructFromSpec(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: `${idlInfo.interfaceName}_SendGoal_Response`,
+      },
+      dir,
+      sendGoalResponseSpec
+    );
+
+    const sendGoalSrv = generateServiceJSStruct(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: `${idlInfo.interfaceName}_SendGoal`,
+      },
+      dir
+    );
+
+    const getResultRequestSpec = actionMsgs.createGetResultRequestSpec(
+      idlInfo.pkgName,
+      idlInfo.interfaceName
+    );
+    const getResultRequestMsg = generateMessageJSStructFromSpec(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: `${idlInfo.interfaceName}_GetResult_Request`,
+      },
+      dir,
+      getResultRequestSpec
+    );
+
+    const getResultResponseSpec = actionMsgs.createGetResultResponseSpec(
+      idlInfo.pkgName,
+      idlInfo.interfaceName
+    );
+    const getResultResponseMsg = generateMessageJSStructFromSpec(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: `${idlInfo.interfaceName}_GetResult_Response`,
+      },
+      dir,
+      getResultResponseSpec
+    );
+
+    const getResultSrv = generateServiceJSStruct(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: `${idlInfo.interfaceName}_GetResult`,
+      },
+      dir
+    );
+
+    const feedbackMessageSpec = actionMsgs.createFeedbackMessageSpec(
+      idlInfo.pkgName,
+      idlInfo.interfaceName
+    );
+    const feedbackMessageMsg = generateMessageJSStructFromSpec(
+      {
+        pkgName: idlInfo.pkgName,
+        subFolder: idlInfo.subFolder,
+        interfaceName: `${idlInfo.interfaceName}_FeedbackMessage`,
+      },
+      dir,
+      feedbackMessageSpec
+    );
+
+    const fileName =
+      idlInfo.pkgName +
+      '__' +
+      idlInfo.subFolder +
+      '__' +
+      idlInfo.interfaceName +
+      '.js';
+    const generatedCode = generateAction({ actionInfo: idlInfo });
+    const actionDir = path.join(dir, idlInfo.pkgName);
+    const action = writeGeneratedCode(actionDir, fileName, generatedCode);
+
+    await Promise.all([
+      goalMsg,
+      resultMsg,
+      feedbackMsg,
+      sendGoalRequestMsg,
+      sendGoalResponseMsg,
+      sendGoalSrv,
+      getResultRequestMsg,
+      getResultResponseMsg,
+      getResultSrv,
+      feedbackMessageMsg,
+      action,
+    ]);
+  }
+}
+
 module.exports = generateJSStructFromIDL;

package/rosidl_gen/index.js

@@ -18,10 +18,8 @@ const fse = require('../lib/utils.js');
 const generateJSStructFromIDL = require('./idl_generator.js');
 const packages = require('./packages.js');
 const path = require('path');
-const idlConvertor = require('../rosidl_convertor/idl_convertor.js');
 const generatedRoot = path.join(__dirname, '../generated/');
 const serviceMsgPath = path.join(generatedRoot, 'srv_msg');
-const idlPath = path.join(generatedRoot, 'share');
 const useIDL = !!process.argv.find((arg) => arg === '--idl');
 
 function getInstalledPackagePaths() {
@@ -35,17 +33,10 @@ async function generateInPath(path) {
       (await packages.findPackagesInDirectory(path)).values()
     );
   } else {
+    // Direct IDL parsing: pass .idl files to the generator which uses
+    // rosidl_parser to parse them directly (no .msg/.srv/.action conversion).
     const idlPkgs = await packages.findPackagesInDirectory(path, useIDL);
-    await fse.ensureDir(idlPath);
-    const promises = [];
-    idlPkgs.forEach((pkg) => {
-      pkg.idls.forEach((idl) => {
-        promises.push(idlConvertor(idl.pkgName, idl.filePath, idlPath));
-      });
-    });
-    await Promise.all(promises);
-    const pkgsFromIdl = await packages.findPackagesInDirectory(idlPath, false);
-    pkgsInfo = Array.from(pkgsFromIdl.values());
+    pkgsInfo = Array.from(idlPkgs.values());
   }
 
   await Promise.all(

package/rosidl_gen/packages.js

@@ -150,9 +150,7 @@ async function generateMsgForSrv(filePath, interfaceInfo, pkgMap) {
   const arr = data.split(/-{3,}/);
   if (arr.length == 2) {
     const packagePath = path.join(serviceMsgPath, interfaceInfo.pkgName);
-    if (!fs.existsSync(packagePath)) {
-      fs.mkdirSync(packagePath);
-    }
+    fs.mkdirSync(packagePath, { recursive: true });
 
     await fsp.writeFile(path.join(packagePath, requestMsgName), arr[0]);
     await fsp.writeFile(path.join(packagePath, responseMsgName), arr[1]);

package/rosidl_gen/primitive_types.js

@@ -26,14 +26,14 @@ const StringRefStruct = StructType({
 
 function initString(str, own = false) {
   if (own) {
-    if ((!str) instanceof Buffer) {
+    if (!(str instanceof Buffer)) {
       throw new TypeError(
         'Invalid argument: should provide a Node Buffer to bindingsStringInit()'
       );
     }
     rclnodejs.initString(str);
   } else {
-    if ((!str) instanceof StringRefStruct) {
+    if (!(str instanceof StringRefStruct)) {
       throw new TypeError(
         'Invalid argument: should provide a type of StringRefStruct'
       );