@dsivd/prestations-ng 19.2.0-beta.14 → 19.2.0-beta.15

package/INTRODUCTION_ANGULAR_SIGNALS.md

@@ -338,7 +338,7 @@ It's the most telling example to show the team: **the signal drives the user inp
 
 ### `rxResource()` — asynchronous calls driven by a signal, with loading/error state included
 
-An alternative to `toSignal()` when you also want state tracking (loading, error, reload) without coding it by hand. `rxResource()` accepts an `Observable` as data source, and is triggered again automatically when the signals the `request` depends on change.
+An alternative to `toSignal()` when you also want state tracking (loading, error, reload) without coding it by hand. `rxResource()` accepts an `Observable` as data source, and is triggered again automatically when the signals read by its `params` function change.
 
 ```ts
 import { rxResource } from '@angular/core/rxjs-interop';
@@ -346,8 +346,8 @@ import { rxResource } from '@angular/core/rxjs-interop';
 readonly userId = input.required<string>();
 
 readonly userResource = rxResource({
-  request: () => this.userId(),
-  loader: ({ request: id }) => this.userService.getUser(id), // Observable<User>
+  params: () => this.userId(),
+  stream: ({ params: id }) => this.userService.getUser(id), // Observable<User>
 });
 
 // in the template: userResource.value(), userResource.isLoading(), userResource.error()
@@ -373,8 +373,8 @@ ngOnInit(): void {
 ```ts
 // 🟢 After: rxResource(), loading/error included, automatic re-fetch if userId() changes
 readonly userResource = rxResource({
-  request: () => this.userId(),
-  loader: ({ request: id }) => this.userService.getUser(id),
+  params: () => this.userId(),
+  stream: ({ params: id }) => this.userService.getUser(id),
 });
 // userResource.value(), userResource.isLoading(), userResource.error()
 ```
@@ -423,6 +423,50 @@ The `async` pipe stays fully legitimate when the `Observable` is consumed **only
 
     It also applies between layers: a service can compose entirely in RxJS (`debounceTime`, `retry`, `combineLatest`...) and stay testable independently of any component — it's the consuming component, "at the edge", that converts to a signal when displaying.
 
+### And the `BehaviorSubject`s?
+
+> 🎤 a `BehaviorSubject` holds a current value like a signal, but it is also a stream: we don't convert them systematically, we look at what it represents and who consumes it.
+
+It becomes a `signal()` when it is a **private state**, written with `next()` and read with `getValue()` or `| async`, without any operator behind it:
+
+```ts
+// 🔴 A state kept in a BehaviorSubject
+private readonly selectedTab = new BehaviorSubject<Tab>('summary');
+
+// 🟢 The same state in a signal: readable in a computed(), no subscription
+private readonly selectedTab = signal<Tab>('summary');
+```
+
+It stays in RxJS when:
+
+- it is the **source of an RxJS chain** (`switchMap` to an HTTP call, `debounceTime`, `combineLatest`...): as a signal, it would have to go back through `toObservable()`, which emits later (through an `effect()`) and only the last value of several writes in a row. A useless round trip, and the timing changes
+- it carries **events**, not a state: a signal ignores a value equal to the current one (`Object.is`) and merges the writes in a row
+- it is part of the **public API** of a library or a shared service: replacing the `Observable` breaks its consumers. If they need a signal, add one next to it (`toSignal()` in the service) rather than replacing it
+- some code relies on the **synchronous notification**: `subscribe()` is called at each `next()`, right away, whereas an `effect()` runs later, once for several writes
+
+```ts
+// 🔴 An event turned into a signal: the second reload triggers nothing
+private readonly reloadTrigger = signal(true);
+
+reload(): void {
+  this.reloadTrigger.set(true); // same value as before: no notification
+}
+
+// 🟢 An event stays a stream: each next() counts
+private readonly reloadTrigger = new Subject<void>();
+
+readonly alerts$ = this.reloadTrigger.pipe(
+  startWith(undefined),
+  switchMap(() => this.alertService.getAlerts()),
+);
+
+reload(): void {
+  this.reloadTrigger.next();
+}
+```
+
+> ⚠️ In a zoneless application, the `BehaviorSubject` itself is not the problem: a `subscribe()` writing a field read by the template, without notifying Angular, is. Fix the consumer with `toSignal()` or `| async` (see "Displaying an asynchronous state" in [GOOD_PRACTICES.md](GOOD_PRACTICES.md)).
+
 ---
 
 ## 7. Pitfall #1: mutation vs reassignment
@@ -501,3 +545,4 @@ export class ContactListComponent {
 - I never mutate a signal value in place anymore — always `.set()`/`.update()` with a new reference
 - I know when to use `untracked()` in an `effect()`
 - I don't try to replace all my RxJS with signals — I keep RxJS for composed async (HTTP, debounce, switchMap...) and I only convert to a signal at the edge, with `toSignal()`/`toObservable()`/`rxResource()`
+- I only turn a `BehaviorSubject` into a signal when it is a private state without operators — the sources of RxJS chains, the events and the public APIs stay in RxJS

package/package.json

@@ -39,7 +39,7 @@
   "ng-update": {
     "migrations": "./schematics/migration-collection.json"
   },
-  "version": "19.2.0-beta.14",
+  "version": "19.2.0-beta.15",
   "module": "fesm2022/dsivd-prestations-ng.mjs",
   "typings": "types/dsivd-prestations-ng.d.ts",
   "exports": {