resource, rxResource, httpResource

import { Component, resource, signal } from '@angular/core';

@Component({ /* ... */ })
export class UserProfile {
  readonly userId = signal<number | undefined>(1);

  readonly user = resource({
    // 1. params: o funcție reactivă. Când rezultatul se schimbă → se reîncarcă.
    //    Dacă întoarce undefined → status 'idle', loader-ul NU rulează.
    params: () => this.userId(),

    // 2. loader: primește params + un AbortSignal (cererea veche e anulată automat)
    loader: async ({ params: id, abortSignal }) => {
      const res = await fetch(`/api/users/${id}`, { signal: abortSignal });
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      return (await res.json()) as User;
    },
  });
}

user.value();      // Signal<T | undefined> — ultima valoare (sau defaultValue)
user.hasValue();   // type guard: true dacă value() nu e undefined
user.status();     // 'idle' | 'loading' | 'reloading' | 'resolved' | 'error' | 'local'
user.isLoading();  // true pentru 'loading' și 'reloading'
user.error();      // Error | undefined
user.reload();     // reîncarcă cu aceiași params (status 'reloading', value rămâne)

// Scriere locală (ex. update optimist) → status devine 'local'
user.set(newUser);
user.update((u) => ({ ...u!, name: 'Nou' }));

user.asReadonly(); // expui fără set/update
user.snapshot();   // v21.2: { status, value | error } într-un singur semnal

import { httpResource } from '@angular/common/http';

export class UserSearch {
  readonly query = signal('');
  readonly role = signal<Role | ''>('');

  // Forma simplă: funcție care întoarce URL-ul (undefined → idle)
  readonly user = httpResource<UserDto>(() => `/api/users/${this.userId()}`);

  // Forma completă: obiect de request + opțiuni
  readonly users = httpResource<PageDto<UserDto>>(
    () => ({
      url: '/api/users',
      params: { q: this.query(), ...(this.role() ? { role: this.role() } : {}) },
      headers: { 'X-Client': 'atlas' },
    }),
    { defaultValue: { items: [], total: 0 } }, // value() nu mai e niciodată undefined
  );
}

// Alte formate:
httpResource.text(() => '/api/readme');
httpResource.blob(() => `/api/files/${id()}`);
httpResource.arrayBuffer(() => '/api/binary');

import { z } from 'zod';

const UserSchema = z.object({ id: z.number(), name: z.string(), email: z.email() });

// `parse` validează/transformă răspunsul — eroarea ajunge în user.error()
readonly user = httpResource(() => `/api/users/${this.id()}`, {
  parse: UserSchema.parse,
});

// sau mapare DTO → model de domeniu
readonly product = httpResource(() => `/api/products/${this.id()}`, {
  parse: (dto: ProductDto) => toProduct(dto),
});

import { rxResource } from '@angular/core/rxjs-interop';

export class Orders {
  private readonly api = inject(OrdersApi); // întoarce Observable-uri

  readonly status = signal<OrderStatus>('open');

  readonly orders = rxResource({
    params: () => ({ status: this.status() }),
    stream: ({ params }) => this.api.list(params.status), // Observable<Order[]>
    defaultValue: [],
  });
}
// La schimbarea params, abonarea veche e închisă (ca switchMap).
// Un stream poate emite de mai multe ori (ex. websocket) — value() se actualizează la fiecare emisie.

import { ResourceParamsStatus, resource } from '@angular/core';

// v22: în params poți „arunca” un status special
readonly report = resource({
  params: () => {
    const range = this.range();
    if (!range) throw ResourceParamsStatus.IDLE;        // nimic de încărcat încă
    if (!this.permissions.hasValue()) throw ResourceParamsStatus.LOADING; // așteaptă altceva
    return range;
  },
  loader: ({ params }) => this.api.report(params),
});

// Înlănțuire de resurse cu ctx.chain(): orders așteaptă user
readonly user = httpResource<User>(() => '/api/me');
readonly orders = httpResource<Order[]>((ctx) => {
  const user = ctx.chain(this.user);
  return user ? `/api/users/${user.id}/orders` : undefined;
});
// cât timp user se încarcă → orders e 'loading'; dacă user dă eroare → și orders e în eroare

// resource / httpResource sunt pentru CITIRE (GET).
// Pentru scrieri (POST/PUT/DELETE) folosește HttpClient direct, apoi actualizează resursa.

export class TodoStore {
  private readonly http = inject(HttpClient);
  readonly todos = httpResource<Todo[]>(() => '/api/todos', { defaultValue: [] });

  async add(title: string) {
    const created = await firstValueFrom(this.http.post<Todo>('/api/todos', { title }));
    this.todos.update((list) => [...list, created]); // update local, fără refetch
  }

  async remove(id: number) {
    this.todos.update((list) => list.filter((t) => t.id !== id)); // optimist
    try {
      await firstValueFrom(this.http.delete(`/api/todos/${id}`));
    } catch {
      this.todos.reload(); // rollback simplu: reîncarci de pe server
    }
  }
}

resource({ params: () => p(), loader: async ({ params, abortSignal, previous }) => ... });
rxResource({ params: () => p(), stream: ({ params }) => obs$ });
httpResource<T>(() => url | { url, method, params, headers, body } | undefined, { defaultValue, parse });

r.value()  r.hasValue()  r.status()  r.isLoading()  r.error()  r.reload()  r.set()  r.update()

params → undefined            ⇒ 'idle'
params → throw ResourceParamsStatus.IDLE / LOADING   (v22)
(ctx) => ctx.chain(alta)      ⇒ înlănțuire                (v22)