signal() și computed()

import { computed, signal, Signal, WritableSignal } from '@angular/core';

const name: WritableSignal<string> = signal('Ana');

name();                        // citire → 'Ana'
name.set('Maria');             // scriere directă
name.update((n) => n.toUpperCase()); // scriere pe baza valorii vechi

const greeting: Signal<string> = computed(() => `Salut, ${name()}!`);
greeting();                    // 'Salut, MARIA!'
// greeting.set(...)           ✗ computed e read-only

const readonlyName: Signal<string> = name.asReadonly(); // expui fără drept de scriere

interface CartItem {
  id: number;
  name: string;
  price: number;
  qty: number;
}

export class Cart {
  protected readonly items = signal<CartItem[]>([]);
  protected readonly filter = signal('');

  // ✓ Tot ce se poate calcula din altceva = computed()
  protected readonly visible = computed(() =>
    this.items().filter((i) => i.name.toLowerCase().includes(this.filter().toLowerCase())),
  );
  protected readonly subtotal = computed(() =>
    this.items().reduce((sum, i) => sum + i.price * i.qty, 0),
  );
  protected readonly vat = computed(() => Math.round(this.subtotal() * 0.19));
  protected readonly total = computed(() => this.subtotal() + this.vat());
  protected readonly freeShipping = computed(() => this.subtotal() >= 1000);

  protected changeQty(id: number, delta: number): void {
    this.items.update((items) =>
      items.map((i) => (i.id === id ? { ...i, qty: Math.max(0, i.qty + delta) } : i)),
    );
  }
}

const tags = signal(['a', 'b']);

// ✗ Mutație: aceeași referință de array → Angular NU află nimic
tags().push('c');
tags.set(tags()); // tot nu ajută: Object.is(vechi, nou) === true

// ✓ Mereu o referință nouă
tags.update((t) => [...t, 'c']);                    // adăugare
tags.update((t) => t.filter((x) => x !== 'a'));     // ștergere
tags.update((t) => t.map((x) => (x === 'b' ? 'B' : x))); // modificare

const user = signal({ name: 'Ana', address: { city: 'Cluj' } });
// ✗ user().address.city = 'Iași';
// ✓
user.update((u) => ({ ...u, address: { ...u.address, city: 'Iași' } }));

import { signal } from '@angular/core';

interface Filters {
  query: string;
  page: number;
}

// Implicit: egalitate prin Object.is (referință).
// Cu `equal` decizi tu când două valori sunt „la fel” → nu notifică degeaba.
const filters = signal<Filters>(
  { query: '', page: 1 },
  { equal: (a, b) => a.query === b.query && a.page === b.page },
);

filters.set({ query: '', page: 1 }); // obiect nou, dar „egal” → NIMENI nu e notificat

// Merge și pe computed:
const ids = computed(() => users().map((u) => u.id), {
  equal: (a, b) => a.length === b.length && a.every((id, i) => id === b[i]),
});

import { effect, signal, untracked } from '@angular/core';

const user = signal('Ana');
const theme = signal('dark');

effect(() => {
  // Dependență: user — efectul rulează din nou când user se schimbă
  const name = user();

  // Citire FĂRĂ dependență: schimbarea temei NU re-rulează efectul
  const currentTheme = untracked(theme);

  console.log(`[analytics] ${name} a deschis pagina (tema: ${currentTheme})`);
});

// untracked acceptă și o funcție — util când apelezi cod care citește semnale intern
effect(() => {
  const id = selectedId();
  untracked(() => this.logger.log(`Selectat ${id}`)); // logger-ul poate citi orice semnal
});

import { Service, computed, signal } from '@angular/core';

@Service()
export class CounterStore {
  // Scrierea e privată: doar store-ul își modifică starea…
  private readonly _count = signal(0);

  // …iar în afară expui doar citire.
  readonly count = this._count.asReadonly();
  readonly isZero = computed(() => this._count() === 0);

  increment(): void {
    this._count.update((c) => c + 1);
  }
}

// CREARE
const a = signal(0);                       // WritableSignal<number>
const b = signal<User | null>(null);       // tip explicit când pornești cu null
const c = computed(() => a() * 2);         // Signal<number>, read-only, lazy, memoizat

// CITIRE
a();                                       // în TS și în template: {{ a() }}

// SCRIERE
a.set(5);
a.update((v) => v + 1);

// EXPUNERE SIGURĂ
readonly value = this._value.asReadonly();

// OPȚIUNI
signal(x, { equal: (p, n) => p.id === n.id, debugName: 'selected' });

// CITIRE FĂRĂ DEPENDENȚĂ
untracked(a);  untracked(() => a() + b());

// VERIFICĂRI
isSignal(x);  isWritableSignal(x);