doc: update documentation for reactiv computation

Author: rainerhahnekamp

projects/www/src/app/pages/guide/signals/rxjs-integration.md

@@ -6,7 +6,7 @@ RxJS is still a major part of NgRx and the Angular ecosystem, and the `@ngrx/sig
 
 The `rxMethod` is a standalone factory function designed for managing side effects by utilizing RxJS APIs.
 It takes a chain of RxJS operators as input and returns a reactive method.
-The reactive method can accept a static value, signal, or observable as an input argument.
+The reactive method can accept a static value, a reactive computation (like a Signal), or observable as an input argument.
 Input can be typed by providing a generic argument to the `rxMethod` function.
 
 <ngrx-code-example>
@@ -21,7 +21,7 @@ import { rxMethod } from '@ngrx/signals/rxjs-interop';
 })
 export class Numbers {
   // 👇 This reactive method will have an input argument
-  // of type `number | Signal<number> | Observable<number>`.
+  // of type `number | (() => number) | Observable<number>`.
   readonly logDoubledNumber = rxMethod<number>(
     // 👇 RxJS operators are chained together using the `pipe` function.
     pipe(
@@ -63,7 +63,7 @@ export class Numbers {
 }
 ```
 
-When a reactive method is called with a signal, the reactive chain is executed every time the signal value changes.
+When a reactive method is called with a reactive computation - like a Signal - the reactive chain is executed every time the signal value changes.
 
 ```ts
 import { Component, signal } from '@angular/core';
@@ -92,6 +92,37 @@ export class Numbers {
 }
 ```
 
+And here the same example with a more generic reactive computation.
+
+```ts
+import { Component, signal } from '@angular/core';
+import { map, pipe, tap } from 'rxjs';
+import { rxMethod } from '@ngrx/signals/rxjs-interop';
+
+@Component({
+  /* ... */
+})
+export class Numbers {
+  readonly logDoubledNumber = rxMethod<number>(
+    pipe(
+      map((num) => num * 2),
+      tap(console.log)
+    )
+  );
+
+  constructor() {
+    const a = signal(5);
+    const b = signal(2);
+
+    this.logDoubledNumber(() => a() + b());
+    // console output: 20
+
+    setTimeout(() => b.set(10), 3_000);
+    // console output after 3 seconds: 40
+  }
+}
+```
+
 When a reactive method is called with an observable, the reactive chain is executed every time the observable emits a new value.
 
 ```ts
@@ -268,7 +299,7 @@ export class Numbers implements OnInit {
 
 <ngrx-docs-alert type="inform">
 
-If the injector is not provided when calling the reactive method with a signal or observable outside the injection context, a warning message about a potential memory leak is displayed in development mode.
+If the injector is not provided when calling the reactive method with a reactive computation or observable outside the injection context, a warning message about a potential memory leak is displayed in development mode.
 
 </ngrx-docs-alert>
 

projects/www/src/app/pages/guide/signals/signal-method.md

@@ -1,6 +1,6 @@
 # SignalMethod
 
-`signalMethod` is a standalone factory function used for managing side effects with Angular signals. It accepts a callback and returns a processor function that can handle either a static value or a signal. The input type can be specified using a generic type argument:
+`signalMethod` is a standalone factory function used for managing side effects with Angular signals. It accepts a callback and returns a processor function that can handle either a static value or a reactive computation, i.e. either a Signal or a function, which will be tracked automatically. The input type can be specified using a generic type argument:
 
 <ngrx-code-example>
 
@@ -13,7 +13,7 @@ import { signalMethod } from '@ngrx/signals';
 })
 export class Numbers {
   // 👇 This method will have an input argument
-  // of type `number | Signal<number>`.
+  // of type `number | (() => number)`.
   readonly logDoubledNumber = signalMethod<number>((num) => {
     const double = num * 2;
     console.log(double);
@@ -23,7 +23,7 @@ export class Numbers {
 
 </ngrx-code-example>
 
-`logDoubledNumber` can be called with a static value of type `number`, or a Signal of type `number`:
+`logDoubledNumber` can be called with a static value of type `number`, or a reactive computation of type `number`. Since a Signal is a function returning a value, it is also a reactive computation.
 
 ```ts
 @Component({
@@ -49,6 +49,30 @@ export class Numbers {
 }
 ```
 
+Finally, a reactive computation example shows an automaticaly tracked computation, built from multiple Signals.
+
+```ts
+@Component({
+  /* ... */
+})
+export class Numbers {
+  readonly logDoubledNumber = signalMethod<number>((num) => {
+    const double = num * 2;
+    console.log(double);
+  });
+
+  constructor() {
+    const num1 = signal(1);
+    const num2 = signal(1);
+    this.logDoubledNumber(() => num1() + num2());
+    // console output: 4
+
+    setTimeout(() => num1.set(2), 3_000);
+    // console output after 3 seconds: 6
+  }
+}
+```
+
 ## Automatic Cleanup
 
 `signalMethod` uses an `effect` internally to track the Signal changes.
@@ -184,9 +208,9 @@ export class Numbers {
 
 However, `signalMethod` offers three distinctive advantages over `effect`:
 
-- **Flexible Input**: The input argument can be a static value, not just a signal. Additionally, the processor function can be called multiple times with different inputs.
+- **Flexible Input**: The input argument can be a static value, not just a reactive computation. Additionally, the processor function can be called multiple times with different inputs.
 - **No Injection Context Required**: Unlike an `effect`, which requires an injection context or an Injector, `signalMethod`'s "processor function" can be called without an injection context.
-- **Explicit Tracking**: Only the Signal of the parameter is tracked, while Signals within the "processor function" stay untracked.
+- **Explicit Tracking**: Only the reactive computation of the parameter is tracked, while Signals within the "processor function" stay untracked.
 
 ## `signalMethod` compared to `rxMethod`