Is it bad to call batch recursively in a nested structure?

[fabian-hiller]

Example:

function updateNestedSignals(signalStore, value) {
  batch(() => {
    if (signalStore.kind == 'object') {
      for (const key in signalStore.children) {
        // This will call `batch` again
        updateNestedSignals(signalStore.children[key], value);
      }
    } else {
      signalStore.value = value;
    }
  });
}

I could prevent that by writing this, but not sure if it is necessary.

const noBatch = (fn) => fn();

function updateNestedSignals(signalStore, value, skipBatch = false) {
  (skipBatch ? noBatch : batch)(() => {
    if (signalStore.kind == 'object') {
      for (const key in signalStore.children) {
        updateNestedSignals(signalStore.children[key], value, true);
      }
    } else {
      signalStore.value = value;
    }
  });
}

[rschristian]

Should be fine, batches can be nested:

signals/packages/core/src/index.ts

Lines 82 to 94 in eae850a

	/**
	* Combine multiple value updates into one "commit" at the end of the provided callback.
	*
	* Batches can be nested and changes are only flushed once the outermost batch callback
	* completes.
	*
	* Accessing a signal that has been modified within a batch will reflect its updated
	* value.
	*
	* @param fn The callback function.
	* @returns The value returned by the callback.
	*/
	function batch<T>(fn: () => T): T {

Standard recursive behaviors apply of course, probably want to avoid hundreds/thousands of nested batches, but normal use shouldn't see any problems.