rclnodejs 1.8.1 → 1.8.2

package/lib/lifecycle.js

@@ -291,7 +291,8 @@ class LifecycleNode extends Node {
     // initialize native handle to rcl_lifecycle_state_machine
     this._stateMachineHandle = rclnodejs.createLifecycleStateMachine(
       this.handle,
-      enableCommunicationInterface
+      enableCommunicationInterface,
+      this._clock.handle
     );
 
     // initialize Map<transitionId,TransitionCallback>

package/lib/parameter.js

@@ -883,7 +883,7 @@ function validValue(value, type) {
     return type === ParameterType.PARAMETER_NOT_SET;
   }
 
-  let result = true;
+  let result;
   switch (type) {
     case ParameterType.PARAMETER_NOT_SET:
       result = !value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rclnodejs",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "description": "ROS2.0 JavaScript client with Node.js",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -48,7 +48,7 @@
     "url": "git+https://github.com/RobotWebTools/rclnodejs.git"
   },
   "devDependencies": {
-    "@eslint/js": "^9.36.0",
+    "@eslint/js": "^10.0.1",
     "@types/node": "^25.0.2",
     "@typescript-eslint/eslint-plugin": "^8.18.0",
     "@typescript-eslint/parser": "^8.18.0",
@@ -56,7 +56,7 @@
     "commander": "^14.0.0",
     "coveralls": "^3.1.1",
     "deep-equal": "^2.2.3",
-    "eslint": "^9.16.0",
+    "eslint": "^10.0.2",
     "eslint-config-prettier": "^10.0.2",
     "eslint-plugin-prettier": "^5.2.1",
     "globals": "^17.0.0",

package/rosidl_gen/packages.js

@@ -52,7 +52,12 @@ function getSubFolder(filePath, amentExecuted) {
   }
 
   if (amentExecuted) {
-    return filePath.match(/\w+\/share\/\w+\/(\w+)\//)[1];
+    const match = filePath.match(/\w+\/share\/\w+\/([\w-]+)\//);
+    if (match) {
+      // Handle non-standard subfolder names (e.g., msg-common, msg-ros2)
+      // by extracting only the base interface type before any hyphen.
+      return match[1].split('-')[0];
+    }
   }
   // If the |amentExecuted| equals to false, the file's extension will be assigned as
   // the name of sub folder.

package/src/rcl_bindings.cpp

@@ -14,7 +14,7 @@
 
 #include "rcl_bindings.h"
 
-#include <node.h>
+#include <node_version.h>
 #include <rcl/arguments.h>
 #include <rcl/rcl.h>
 

package/src/rcl_lifecycle_bindings.cpp

@@ -71,7 +71,30 @@ Napi::Value CreateLifecycleStateMachine(const Napi::CallbackInfo& info) {
   const rosidl_service_type_support_t* gs =
       GetServiceTypeSupport("lifecycle_msgs", "GetState");
 
-#if ROS_VERSION >= 2105
+#if ROS_VERSION >= 5000  // ROS2 Rolling
+  rcl_lifecycle_state_machine_options_t options =
+      rcl_lifecycle_get_default_state_machine_options();
+  options.enable_com_interface = info[1].As<Napi::Boolean>().Value();
+
+  RclHandle* clock_handle = RclHandle::Unwrap(info[2].As<Napi::Object>());
+  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(clock_handle->ptr());
+
+  THROW_ERROR_IF_NOT_EQUAL(
+      RCL_RET_OK,
+      rcl_lifecycle_state_machine_init(state_machine, node, clock, pn, cs, gs,
+                                       gas, gat, gtg, &options),
+      rcl_get_error_string().str);
+
+  auto js_obj = RclHandle::NewInstance(
+      env, state_machine, node_handle, [node, env](void* ptr) {
+        rcl_lifecycle_state_machine_t* state_machine =
+            reinterpret_cast<rcl_lifecycle_state_machine_t*>(ptr);
+        rcl_ret_t ret = rcl_lifecycle_state_machine_fini(state_machine, node);
+        free(ptr);
+        THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                           rcl_get_error_string().str);
+      });
+#elif ROS_VERSION >= 2105
   rcl_lifecycle_state_machine_options_t options =
       rcl_lifecycle_get_default_state_machine_options();
   options.enable_com_interface = info[1].As<Napi::Boolean>().Value();

package/test_data_integrity.js

@@ -0,0 +1,108 @@
+// Data integrity + throughput test for subscription
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+const PUBLISH_HZ = 50;
+const TEST_DURATION_SEC = 10;
+
+async function main() {
+  await rclnodejs.init();
+
+  const pubNode = new rclnodejs.Node('data_pub_node');
+  const subNode = new rclnodejs.Node('data_sub_node');
+
+  const publisher = pubNode.createPublisher(
+    'std_msgs/msg/Float64MultiArray',
+    '/data_integrity_topic'
+  );
+
+  let msgCount = 0;
+  let errCount = 0;
+  let lastTs = null;
+  const hzSamples = [];
+  const errors = [];
+
+  subNode.createSubscription(
+    'std_msgs/msg/Float64MultiArray',
+    '/data_integrity_topic',
+    (msg) => {
+      const now = Date.now();
+      msgCount++;
+
+      // --- Data validation ---
+      // Each published message has data = [seqNo, seqNo*1.5, seqNo*2.5]
+      // Verify structure and values
+      if (!msg || !msg.data) {
+        errCount++;
+        errors.push(`msg#${msgCount}: missing data field, got: ${JSON.stringify(msg)}`);
+      } else if (!Array.isArray(msg.data) && !(msg.data instanceof Float64Array)) {
+        errCount++;
+        errors.push(`msg#${msgCount}: data is not array-like, type=${typeof msg.data}`);
+      } else if (msg.data.length !== 3) {
+        errCount++;
+        errors.push(`msg#${msgCount}: expected 3 elements, got ${msg.data.length}`);
+      } else {
+        const seqNo = msg.data[0];
+        const expectedB = seqNo * 1.5;
+        const expectedC = seqNo * 2.5;
+
+        if (Math.abs(msg.data[1] - expectedB) > 1e-9) {
+          errCount++;
+          errors.push(
+            `msg#${msgCount}: data[1] expected ${expectedB}, got ${msg.data[1]}`
+          );
+        }
+        if (Math.abs(msg.data[2] - expectedC) > 1e-9) {
+          errCount++;
+          errors.push(
+            `msg#${msgCount}: data[2] expected ${expectedC}, got ${msg.data[2]}`
+          );
+        }
+      }
+
+      if (lastTs) {
+        hzSamples.push(1000 / (now - lastTs));
+      }
+      lastTs = now;
+    }
+  );
+
+  pubNode.spin();
+  subNode.spin();
+
+  let pubSeq = 0;
+  const pubInterval = setInterval(() => {
+    pubSeq++;
+    publisher.publish({ data: [pubSeq, pubSeq * 1.5, pubSeq * 2.5] });
+  }, 1000 / PUBLISH_HZ);
+
+  setTimeout(() => {
+    clearInterval(pubInterval);
+
+    console.log(`\n=== Data Integrity Test Results ===`);
+    console.log(`Published:    ${pubSeq} messages at ${PUBLISH_HZ} Hz`);
+    console.log(`Received:     ${msgCount} messages`);
+    console.log(`Data errors:  ${errCount}`);
+
+    if (errors.length > 0) {
+      console.log(`\nFirst 10 errors:`);
+      errors.slice(0, 10).forEach((e) => console.log(`  ${e}`));
+    }
+
+    if (hzSamples.length > 0) {
+      const avgHz = hzSamples.reduce((a, b) => a + b, 0) / hzSamples.length;
+      console.log(`\nAvg Hz:       ${avgHz.toFixed(2)}`);
+    }
+
+    const pass = errCount === 0 && msgCount > 0;
+    console.log(`\nResult:       ${pass ? 'PASS - all data correct' : 'FAIL'}`);
+
+    pubNode.stop();
+    subNode.stop();
+    rclnodejs.shutdown();
+    process.exit(pass ? 0 : 1);
+  }, TEST_DURATION_SEC * 1000);
+}
+
+main().catch(console.error);

package/test_repro_exact.js

@@ -0,0 +1,57 @@
+// Thorough latency/throughput test matching the exact issue scenario
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+async function main() {
+  await rclnodejs.init();
+
+  const node = new rclnodejs.Node('test_node');
+
+  let lastTs;
+  let msgCount = 0;
+  const hzSamples = [];
+
+  node.createSubscription(
+    'std_msgs/msg/Float64MultiArray',
+    '/map_to_base_link_pose2d',
+    (msg) => {
+      const now = Date.now();
+      msgCount++;
+      if (lastTs) {
+        const hz = 1000 / (now - lastTs);
+        hzSamples.push(hz);
+        console.log('Raw Hz:', hz.toFixed(2));
+      }
+      lastTs = now;
+    }
+  );
+
+  rclnodejs.spin(node);
+
+  console.log('Waiting for messages on /map_to_base_link_pose2d at ~10Hz...');
+  console.log('Run this in another terminal:');
+  console.log(
+    '  ros2 topic pub -r 10 /map_to_base_link_pose2d std_msgs/msg/Float64MultiArray "{data: [1.0, 2.0, 3.0]}"'
+  );
+
+  setTimeout(() => {
+    if (hzSamples.length > 0) {
+      const avgHz = hzSamples.reduce((a, b) => a + b, 0) / hzSamples.length;
+      console.log(`\n--- Summary ---`);
+      console.log(`Messages: ${msgCount}, Avg Hz: ${avgHz.toFixed(2)}`);
+      if (avgHz < 5) {
+        console.log('*** REGRESSION DETECTED ***');
+      } else {
+        console.log('Performance OK');
+      }
+    } else {
+      console.log('No messages received');
+    }
+    node.stop();
+    rclnodejs.shutdown();
+    process.exit(0);
+  }, 15000);
+}
+
+main().catch(console.error);

package/test_repro_hz.js

@@ -0,0 +1,86 @@
+// Reprocer for https://github.com/RobotWebTools/rclnodejs/issues/1394
+// Tests subscription throughput at ~10Hz publishing rate
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+const PUBLISH_HZ = 10;
+const TEST_DURATION_SEC = 10;
+
+async function main() {
+  await rclnodejs.init();
+
+  const pubNode = new rclnodejs.Node('test_pub_node');
+  const subNode = new rclnodejs.Node('test_sub_node');
+
+  const publisher = pubNode.createPublisher(
+    'std_msgs/msg/Float64MultiArray',
+    '/test_hz_topic'
+  );
+
+  let msgCount = 0;
+  let lastTs = null;
+  const hzSamples = [];
+
+  subNode.createSubscription(
+    'std_msgs/msg/Float64MultiArray',
+    '/test_hz_topic',
+    (msg) => {
+      const now = Date.now();
+      msgCount++;
+      if (lastTs) {
+        const hz = 1000 / (now - lastTs);
+        hzSamples.push(hz);
+      }
+      lastTs = now;
+    }
+  );
+
+  pubNode.spin();
+  subNode.spin();
+
+  // Publish at target Hz
+  let pubCount = 0;
+  const pubInterval = setInterval(() => {
+    publisher.publish({ data: [1.0, 2.0, 3.0] });
+    pubCount++;
+  }, 1000 / PUBLISH_HZ);
+
+  // Wait for test duration then report
+  setTimeout(() => {
+    clearInterval(pubInterval);
+
+    if (hzSamples.length > 0) {
+      const avgHz =
+        hzSamples.reduce((a, b) => a + b, 0) / hzSamples.length;
+      const minHz = Math.min(...hzSamples);
+      const maxHz = Math.max(...hzSamples);
+
+      console.log(`Published:  ${pubCount} messages`);
+      console.log(`Received:   ${msgCount} messages`);
+      console.log(`Avg Hz:     ${avgHz.toFixed(2)}`);
+      console.log(`Min Hz:     ${minHz.toFixed(2)}`);
+      console.log(`Max Hz:     ${maxHz.toFixed(2)}`);
+      console.log(
+        `Expected:   ~${PUBLISH_HZ} Hz`
+      );
+
+      if (avgHz < PUBLISH_HZ * 0.5) {
+        console.log(
+          `\n*** REGRESSION DETECTED: Average Hz (${avgHz.toFixed(2)}) is less than 50% of expected (${PUBLISH_HZ}) ***`
+        );
+      } else {
+        console.log('\nPerformance looks OK.');
+      }
+    } else {
+      console.log('No messages received!');
+    }
+
+    pubNode.stop();
+    subNode.stop();
+    rclnodejs.shutdown();
+    process.exit(0);
+  }, TEST_DURATION_SEC * 1000);
+}
+
+main().catch(console.error);

package/test_repro_pub.js

@@ -0,0 +1,36 @@
+// Publisher for repro test - runs in separate process
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+const PUBLISH_HZ = parseInt(process.argv[2] || '100');
+
+async function main() {
+  await rclnodejs.init();
+
+  const node = new rclnodejs.Node('test_publisher_node');
+  const publisher = node.createPublisher(
+    'std_msgs/msg/Float64MultiArray',
+    '/test_hz_topic'
+  );
+
+  node.spin();
+
+  let pubCount = 0;
+  console.log(`Publishing at ${PUBLISH_HZ} Hz...`);
+
+  const pubInterval = setInterval(() => {
+    publisher.publish({ data: [1.0, 2.0, 3.0] });
+    pubCount++;
+  }, 1000 / PUBLISH_HZ);
+
+  setTimeout(() => {
+    clearInterval(pubInterval);
+    console.log(`Published ${pubCount} messages total`);
+    node.stop();
+    rclnodejs.shutdown();
+    process.exit(0);
+  }, 15000);
+}
+
+main().catch(console.error);

package/test_repro_stress.js

@@ -0,0 +1,83 @@
+// Multi-frequency stress test for subscription performance
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+const PUBLISH_HZ = parseInt(process.argv[2] || '100');
+const TEST_DURATION_SEC = 10;
+
+async function main() {
+  await rclnodejs.init();
+
+  const pubNode = new rclnodejs.Node('stress_pub_node');
+  const subNode = new rclnodejs.Node('stress_sub_node');
+
+  const publisher = pubNode.createPublisher(
+    'std_msgs/msg/Float64MultiArray',
+    '/stress_test_topic'
+  );
+
+  let msgCount = 0;
+  let lastTs = null;
+  const hzSamples = [];
+
+  subNode.createSubscription(
+    'std_msgs/msg/Float64MultiArray',
+    '/stress_test_topic',
+    (msg) => {
+      const now = Date.now();
+      msgCount++;
+      if (lastTs) {
+        const hz = 1000 / (now - lastTs);
+        hzSamples.push(hz);
+      }
+      lastTs = now;
+    }
+  );
+
+  pubNode.spin();
+  subNode.spin();
+
+  let pubCount = 0;
+
+  // Use high-resolution timer for more precise publishing
+  const intervalMs = 1000 / PUBLISH_HZ;
+  const pubInterval = setInterval(() => {
+    publisher.publish({ data: [1.0, 2.0, 3.0, 4.0, 5.0] });
+    pubCount++;
+  }, intervalMs);
+
+  setTimeout(() => {
+    clearInterval(pubInterval);
+
+    if (hzSamples.length > 0) {
+      const avgHz = hzSamples.reduce((a, b) => a + b, 0) / hzSamples.length;
+      const minHz = Math.min(...hzSamples);
+      const maxHz = Math.max(...hzSamples);
+      const dropRate = ((pubCount - msgCount) / pubCount * 100);
+
+      console.log(`Target:     ${PUBLISH_HZ} Hz`);
+      console.log(`Published:  ${pubCount}`);
+      console.log(`Received:   ${msgCount}`);
+      console.log(`Avg Hz:     ${avgHz.toFixed(2)}`);
+      console.log(`Min Hz:     ${minHz.toFixed(2)}`);
+      console.log(`Max Hz:     ${maxHz.toFixed(2)}`);
+      console.log(`Drop rate:  ${dropRate.toFixed(1)}%`);
+
+      if (avgHz < PUBLISH_HZ * 0.5) {
+        console.log(`FAIL: Avg Hz significantly below target`);
+      } else {
+        console.log(`PASS`);
+      }
+    } else {
+      console.log('No messages received!');
+    }
+
+    pubNode.stop();
+    subNode.stop();
+    rclnodejs.shutdown();
+    process.exit(0);
+  }, TEST_DURATION_SEC * 1000);
+}
+
+main().catch(console.error);

package/test_repro_sub.js

@@ -0,0 +1,64 @@
+// Subscriber for repro test - runs in separate process
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+async function main() {
+  await rclnodejs.init();
+
+  const node = new rclnodejs.Node('test_subscriber_node');
+
+  let msgCount = 0;
+  let lastTs = null;
+  const hzSamples = [];
+  let startTime = null;
+
+  node.createSubscription(
+    'std_msgs/msg/Float64MultiArray',
+    '/test_hz_topic',
+    (msg) => {
+      const now = Date.now();
+      msgCount++;
+      if (!startTime) startTime = now;
+      if (lastTs) {
+        const hz = 1000 / (now - lastTs);
+        hzSamples.push(hz);
+        if (msgCount % 50 === 0) {
+          const recentSamples = hzSamples.slice(-50);
+          const recentAvg =
+            recentSamples.reduce((a, b) => a + b, 0) / recentSamples.length;
+          console.log(
+            `msg#${msgCount} recent avg Hz: ${recentAvg.toFixed(2)}`
+          );
+        }
+      }
+      lastTs = now;
+    }
+  );
+
+  node.spin();
+
+  setTimeout(() => {
+    if (hzSamples.length > 0) {
+      const avgHz =
+        hzSamples.reduce((a, b) => a + b, 0) / hzSamples.length;
+      const minHz = Math.min(...hzSamples);
+      const maxHz = Math.max(...hzSamples);
+      const elapsed = (Date.now() - startTime) / 1000;
+
+      console.log(`\n--- Results ---`);
+      console.log(`Received:   ${msgCount} messages in ${elapsed.toFixed(1)}s`);
+      console.log(`Avg Hz:     ${avgHz.toFixed(2)}`);
+      console.log(`Min Hz:     ${minHz.toFixed(2)}`);
+      console.log(`Max Hz:     ${maxHz.toFixed(2)}`);
+    } else {
+      console.log('No messages received!');
+    }
+
+    node.stop();
+    rclnodejs.shutdown();
+    process.exit(0);
+  }, 12000);
+}
+
+main().catch(console.error);

package/test_xproc_data.js

@@ -0,0 +1,64 @@
+// Cross-process data integrity test: validates data from external ROS2 publisher
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+const EXPECTED_DATA = [1.0, 2.0, 3.0];
+
+async function main() {
+  await rclnodejs.init();
+
+  const node = new rclnodejs.Node('xproc_data_sub');
+  let msgCount = 0;
+  let errCount = 0;
+  const errors = [];
+
+  node.createSubscription(
+    'std_msgs/msg/Float64MultiArray',
+    '/xproc_data_topic',
+    (msg) => {
+      msgCount++;
+
+      if (!msg || !msg.data) {
+        errCount++;
+        errors.push(`msg#${msgCount}: missing data`);
+      } else {
+        const arr = Array.from(msg.data);
+        for (let i = 0; i < EXPECTED_DATA.length; i++) {
+          if (Math.abs(arr[i] - EXPECTED_DATA[i]) > 1e-9) {
+            errCount++;
+            errors.push(
+              `msg#${msgCount}: data[${i}] expected ${EXPECTED_DATA[i]}, got ${arr[i]}`
+            );
+          }
+        }
+        if (arr.length !== EXPECTED_DATA.length) {
+          errCount++;
+          errors.push(
+            `msg#${msgCount}: expected ${EXPECTED_DATA.length} elements, got ${arr.length}`
+          );
+        }
+      }
+    }
+  );
+
+  rclnodejs.spin(node);
+
+  console.log('Listening on /xproc_data_topic for 10s...');
+
+  setTimeout(() => {
+    console.log(`\n=== Cross-Process Data Integrity ===`);
+    console.log(`Received:    ${msgCount} messages`);
+    console.log(`Data errors: ${errCount}`);
+    if (errors.length > 0) {
+      errors.slice(0, 10).forEach((e) => console.log(`  ${e}`));
+    }
+    const pass = errCount === 0 && msgCount > 0;
+    console.log(`Result:      ${pass ? 'PASS' : 'FAIL'}`);
+    node.stop();
+    rclnodejs.shutdown();
+    process.exit(0);
+  }, 10000);
+}
+
+main().catch(console.error);