Add pre-set and post-set parameter callbacks (#1470)

Add `addPreSetParametersCallback()` / `removePreSetParametersCallback()` and `addPostSetParametersCallback()` / `removePostSetParametersCallback()` to the Node class. Pre-set callbacks run before validation and can transform the parameter list (e.g. coerce values); returning an empty list rejects the set. Post-set callbacks run after parameters are successfully applied, for side effects (e.g. reconfiguring a component). Both follow LIFO ordering (newest callback runs first), matching rclpy's `add_pre_set_parameters_callback` / `add_post_set_parameters_callback` behavior.

**Modified: `lib/node.js`** — Added `_preSetParametersCallbacks` and `_postSetParametersCallbacks` arrays. Modified `_setParametersAtomically()` to invoke pre callbacks before validation (merging all returned lists, rejecting on empty) and post callbacks after successful set and ParameterEvent publishing. Added 4 new public methods with JSDoc.

**Modified: `types/node.d.ts`** — Added `PreSetParametersCallback` and `PostSetParametersCallback` type aliases, and all 4 new methods to the Node interface.

**New: `test/test-pre-post-param-callbacks.js`** — 11 tests covering pre (value modification, empty-list rejection, LIFO ordering, removal), post (called on success, skipped on rejection, LIFO ordering, removal), and full chain (pre→on→post order, pre rejection stops chain, on rejection stops post).

Fix : #1469

Author: minggangw

lib/node.js

@@ -161,7 +161,9 @@ class Node extends rclnodejs.ShadowNode {
     this._parameterService = null;
     this._typeDescriptionService = null;
     this._parameterEventPublisher = null;
+    this._preSetParametersCallbacks = [];
     this._setParametersCallbacks = [];
+    this._postSetParametersCallbacks = [];
     this._logger = new Logging(rclnodejs.getNodeLoggerName(this.handle));
     this._spinning = false;
     this._enableRosout = options.enableRosout;
@@ -2057,6 +2059,29 @@ class Node extends rclnodejs.ShadowNode {
    * @return {SetParameterResult} - A single collective result.
    */
   _setParametersAtomically(parameters = [], declareParameterMode = false) {
+    // 1) PRE callbacks — pipeline: each callback receives the output of the previous
+    if (this._preSetParametersCallbacks.length > 0) {
+      for (const callback of this._preSetParametersCallbacks) {
+        const result = callback(parameters);
+        if (!Array.isArray(result)) {
+          return {
+            successful: false,
+            reason:
+              'pre-set parameters callback must return an array of Parameters',
+          };
+        }
+        parameters = result;
+        if (parameters.length === 0) {
+          return {
+            successful: false,
+            reason:
+              'parameter list is empty after pre-set callback; set rejected',
+          };
+        }
+      }
+    }
+
+    // 2) Validate
     let result = this._validateParameters(parameters, declareParameterMode);
     if (!result.successful) {
       return result;
@@ -2126,6 +2151,11 @@ class Node extends rclnodejs.ShadowNode {
     // Publish ParameterEvent.
     this._parameterEventPublisher.publish(parameterEvent);
 
+    // POST callbacks — for side effects after successful set
+    for (const callback of this._postSetParametersCallbacks) {
+      callback(parameters);
+    }
+
     return {
       successful: true,
       reason: '',
@@ -2170,6 +2200,82 @@ class Node extends rclnodejs.ShadowNode {
     }
   }
 
+  /**
+   * A callback invoked before parameter validation and setting.
+   * It receives the parameter list and must return a (possibly modified) parameter list.
+   *
+   * @callback PreSetParametersCallback
+   * @param {Parameter[]} parameters - The parameters about to be set.
+   * @returns {Parameter[]} - The modified parameter list to proceed with.
+   *
+   * @see [Node.addPreSetParametersCallback]{@link Node#addPreSetParametersCallback}
+   * @see [Node.removePreSetParametersCallback]{@link Node#removePreSetParametersCallback}
+   */
+
+  /**
+   * Add a callback invoked before parameter validation.
+   * The callback receives the parameter list and must return a (possibly modified)
+   * parameter list. This can be used to coerce, add, or remove parameters before
+   * they are validated and applied. If any pre-set callback returns an empty list,
+   * the set is rejected.
+   *
+   * @param {PreSetParametersCallback} callback - The callback to add.
+   * @returns {undefined}
+   */
+  addPreSetParametersCallback(callback) {
+    this._preSetParametersCallbacks.unshift(callback);
+  }
+
+  /**
+   * Remove a pre-set parameters callback.
+   *
+   * @param {PreSetParametersCallback} callback - The callback to remove.
+   * @returns {undefined}
+   */
+  removePreSetParametersCallback(callback) {
+    const idx = this._preSetParametersCallbacks.indexOf(callback);
+    if (idx > -1) {
+      this._preSetParametersCallbacks.splice(idx, 1);
+    }
+  }
+
+  /**
+   * A callback invoked after parameters have been successfully set.
+   * It receives the final parameter list. For side effects only (return value is ignored).
+   *
+   * @callback PostSetParametersCallback
+   * @param {Parameter[]} parameters - The parameters that were set.
+   * @returns {undefined}
+   *
+   * @see [Node.addPostSetParametersCallback]{@link Node#addPostSetParametersCallback}
+   * @see [Node.removePostSetParametersCallback]{@link Node#removePostSetParametersCallback}
+   */
+
+  /**
+   * Add a callback invoked after parameters are successfully set.
+   * The callback receives the final parameter list. Useful for triggering
+   * side effects (e.g., reconfiguring a component when a parameter changes).
+   *
+   * @param {PostSetParametersCallback} callback - The callback to add.
+   * @returns {undefined}
+   */
+  addPostSetParametersCallback(callback) {
+    this._postSetParametersCallbacks.unshift(callback);
+  }
+
+  /**
+   * Remove a post-set parameters callback.
+   *
+   * @param {PostSetParametersCallback} callback - The callback to remove.
+   * @returns {undefined}
+   */
+  removePostSetParametersCallback(callback) {
+    const idx = this._postSetParametersCallbacks.indexOf(callback);
+    if (idx > -1) {
+      this._postSetParametersCallbacks.splice(idx, 1);
+    }
+  }
+
   /**
    * Get the fully qualified name of the node.
    *