Semnalele pe dinăuntru

const a = signal(1);                                  // producător
const b = signal(2);                                  // producător
const sum = computed(() => a() + b());                // consumator ȘI producător
const product = computed(() => a() * b());
const result = computed(() => sum() + product());     // diamant: a și b ajung aici pe două drumuri

// În timpul rulării unei funcții reactive, Angular ține un „consumator activ”.
// Orice semnal citit acum devine dependența lui. Nu declari nimic: graful se construiește din citiri.

a.set(5)
  │  PUSH: a își crește `version` și anunță consumatorii „live” (template, effect) că POT fi murdari.
  │        Nimic nu se recalculează încă.
  ▼
template / effect marcat dirty  →  change detection programează o randare
  │
  ▼
template citește result()
  │  PULL: result își verifică producătorii (sum, product) — au altă versiune?
  │        sum își verifică producătorii (a, b) — a are altă versiune → sum se recalculează.
  │        Dacă valoarea nouă e EGALĂ cu cea veche, versiunea lui sum nu crește → propagarea se oprește.
  ▼
result se recalculează o singură dată, cu valori deja consistente (glitch-free)

const expensive = computed(() => {
  console.log('calculez…');
  return items().filter(matches).sort(byPrice);
});

items.set(newItems);  // nu se afișează nimic: nimeni n-a citit încă
expensive();          // „calculez…” — prima citire
expensive();          // nimic: valoare memorată (memoized)
items.set(other);     // tot nimic — marcat ca vechi, nu recalculat
expensive();          // „calculez…”

// Implicit: Object.is. Pentru obiecte/array-uri contează REFERINȚA.
const tags = signal(['a', 'b']);
tags.set(['a', 'b']);           // altă referință → valoare „nouă” → consumatorii se recalculează

// Egalitate custom: valoarea nu se schimbă dacă e „la fel” după regula ta
const sameItems = (x: string[], y: string[]) => x.length === y.length && x.every((v, i) => v === y[i]);
const stableTags = signal(['a', 'b'], { equal: sameItems });
stableTags.set(['a', 'b']);     // egal → versiunea nu crește → nimic downstream

// Și un computed are egalitate: dacă rezultatul e egal, propagarea se oprește la el
const parity = computed(() => (n() % 2 ? 'impar' : 'par'));   // n: 0 → 2 → 4 … parity rămâne 'par'

const view = computed(() => {
  if (showDetails()) {
    return details();     // dependențe: showDetails + details
  }
  return summary();       // dependențe: showDetails + summary
});
// La fiecare rulare, lista de producători se reconstruiește din ce s-a citit EFECTIV.
// Cât timp showDetails() e false, schimbarea lui details nu recalculează view.

// View effect: creat în contextul unei componente → rulează ÎNAINTE ca acea componentă
// să fie verificată de change detection; e distrus odată cu componenta.
@Component({ /* ... */ })
export class Profile {
  constructor() {
    effect(() => console.log('profil', this.user()));
  }
}

// Root effect: creat într-un serviciu din root → rulează înaintea verificării tuturor componentelor;
// trăiește cât aplicația.
@Injectable({ providedIn: 'root' })
export class Analytics {
  constructor() {
    effect(() => track(this.route()));
  }
}
// Ambele sunt asincrone (nu rulează în momentul set()), legate de procesul de change detection.

@Component({
  template: `<p>{{ fullName() }}</p>`,   // template-ul e un consumator reactiv
})
export class Card {
  readonly first = signal('Ana');
  readonly fullName = computed(() => `${this.first()} Pop`);
}
// first.set('Ioana') → nodul reactiv al template-ului e marcat dirty → componenta e marcată pentru
// verificare (ca markForCheck) → change detection o re-randează. Fără Zone.js, fără verificarea
// întregului arbore: așa funcționează aplicațiile zoneless.

// ✗ Scriere într-un computed — eroare: „Writing to signals is not allowed in a `computed`”
const total = computed(() => {
  count.set(items().length);       // efect secundar în derivare
  return items().reduce(sum, 0);
});

// ✗ Effect folosit pentru derivare (o randare în plus, risc de bucle)
effect(() => total.set(items().reduce(sum, 0)));

// ✓ Derivarea e un computed
const total2 = computed(() => items().reduce(sum, 0));

// ✗ Mutare: aceeași referință → Object.is spune „egal” → nimic nu se actualizează
items().push(newItem);
// ✓
items.update((list) => [...list, newItem]);

NOD           ROL                     CÂND RULEAZĂ
signal        producător              — (doar își schimbă valoarea și versiunea la set/update)
computed      consumator + producător lazy: la citire, doar dacă vreo dependență s-a schimbat
effect        consumator „live”       asincron, în change detection (view: înaintea componentei; root: înaintea tuturor)
template      consumator „live”       când componenta e re-randată după ce a fost marcată dirty

REGULI
  dependențele = ce citești EFECTIV la ultima rulare (dinamice, pe ramuri)
  egalitate implicită Object.is; { equal } pentru valori „la fel” → oprește propagarea
  computed fără cititori nu se calculează deloc
  nu scrie semnale în computed; nu deriva stare cu effect
  untracked(() => …) citește fără să creeze dependență