Kurs JavaScript i React · Moduł 9: Nowoczesne hooki React

useFormStatus i useActionState - hooki formularzy React 19

8 min czytania ·
W tej lekcji6

W kosmicznej podróży przez galaktyki React formularze to jeden z najważniejszych modułów komunikacyjnych statku. Każdy raport misji, każde polecenie dla systemu nawigacyjnego i każda wiadomość do bazy przechodzi przez formularz. Do tej pory oznaczało to ręczne onSubmit, e.preventDefault(), osobny stan ładowania i kolejny na błędy. React 19 wprowadza akcje formularzy i dwa hooki, useFormStatus i useActionState, które przejmują większość tej pracy.

Server Actions - nowy paradygmat

Zanim poznamy nowe hooki, musimy zrozumieć koncepcję Server Actions. To funkcje oznaczone dyrektywą 'use server', które wykonują się na serwerze, ale można je wywołać prosto z formularza w komponencie klienckim. Dyrektywa działa tylko we frameworku z React Server Components, np. w Next.js z App Routerem, bo ktoś musi uruchomić tę funkcję po stronie serwera. Plik z akcjami wygląda tak:

// actions.js
'use server';

export async function submitMissionReport(formData) {
  const missionName = formData.get('missionName');
  const status = formData.get('status');

  // To wykonuje się na SERWERZE
  await database.missions.create({
    name: missionName,
    status: status,
    timestamp: new Date()
  });

  return { success: true, message: 'Raport zapisany!' };
}

Funkcja jest eksportowana, bo komponent importuje ją jak zwykły moduł. Framework nie wysyła jej kodu do przeglądarki, tylko referencję, przez którą formularz wywoła serwer. Server Action przekazujesz bezpośrednio do atrybutu action formularza:

// MissionForm.jsx
import { submitMissionReport } from './actions';

function MissionForm() {
  return (
    <form action={submitMissionReport}>
      <input name="missionName" placeholder="Nazwa misji" />
      <select name="status">
        <option value="active">Aktywna</option>
        <option value="completed">Ukończona</option>
      </select>
      <button type="submit">Wyślij raport</button>
    </form>
  );
}

Nie piszesz endpointu API ani obsługi onSubmit: React zbiera pola formularza w obiekt FormData i przekazuje go akcji. Ważne: akcją formularza może być też zwykła funkcja asynchroniczna zdefiniowana w komponencie klienckim, bez 'use server'. Tak działają kolejne przykłady i edytor w tej lekcji, bo useFormStatus i useActionState pracują z obydwoma rodzajami akcji.

useFormStatus - status formularza w komponentach potomnych

useFormStatus to hook z pakietu react-dom, który zwraca informacje o stanie wysyłania formularza. Kluczowa zasada: musi być używany w komponencie potomnym elementu <form>, a nie w komponencie, który ten formularz renderuje.

import { useFormStatus } from 'react-dom';

// Komponent przycisku submit - WEWNĄTRZ formularza
function SubmitButton() {
  const { pending, data, method, action } = useFormStatus();

  return (
    <button
      type="submit"
      disabled={pending}
      style={{
        padding: '10px 20px',
        background: pending ? '#333' : '#00d4ff',
        color: pending ? '#666' : '#0a0e17',
        border: 'none',
        borderRadius: '6px',
        cursor: pending ? 'wait' : 'pointer'
      }}
    >
      {pending ? 'Wysyłanie raportu...' : 'Wyślij raport misji'}
    </button>
  );
}

// pending - true, gdy formularz jest w trakcie wysyłania
// data - obiekt FormData z danymi wysyłanego formularza
// method - metoda formularza: 'get' albo 'post'
// action - funkcja przekazana do atrybutu action

Przycisk sam wie, że formularz się wysyła, więc rodzic nie musi przekazywać mu stanu przez propsy. Gdy nic się nie wysyła, pending ma wartość false, a pozostałe pola null.

Praktyczny przykład z useFormStatus

Hook przydaje się nie tylko w przycisku. Każdy komponent wewnątrz formularza może zapytać o jego stan, więc pola same się blokują, a nakładka pokazuje komunikat o transmisji. Formularz MissionReportForm nie przekazuje im żadnych propsów ze stanem:

import { useFormStatus } from 'react-dom';

function MissionInput({ name, label, placeholder }) {
  const { pending } = useFormStatus();
  return (
    <div style={{ marginBottom: '12px' }}>
      <label style={{ color: '#8899aa', display: 'block', marginBottom: '4px' }}>
        {label}
      </label>
      <input
        name={name}
        placeholder={placeholder}
        disabled={pending}
        style={{
          width: '100%',
          padding: '8px 12px',
          background: pending ? '#1a1a2e' : '#0f1729',
          color: '#e0e1dd',
          border: '1px solid #2a3a5c',
          borderRadius: '6px',
          opacity: pending ? 0.5 : 1
        }}
      />
    </div>
  );
}

function LoadingOverlay() {
  const { pending } = useFormStatus();
  if (!pending) return null;
  return (
    <div style={{
      position: 'absolute', top: 0, left: 0, right: 0, bottom: 0,
      background: 'rgba(10, 14, 23, 0.7)',
      display: 'flex', alignItems: 'center', justifyContent: 'center',
      borderRadius: '8px'
    }}>
      <p style={{ color: '#00d4ff' }}>Transmisja w toku...</p>
    </div>
  );
}

function MissionReportForm({ submitAction }) {
  return (
    <form action={submitAction} style={{ position: 'relative' }}>
      <LoadingOverlay />
      <MissionInput name="mission" label="Nazwa misji" placeholder="Np. Alpha Centauri" />
      <MissionInput name="coordinates" label="Współrzędne" placeholder="Np. 14h 29m 43s" />
      <SubmitButton />
    </form>
  );
}

SubmitButton z poprzedniego przykładu działa tu bez zmian. Gdyby wywołać useFormStatus w samym MissionReportForm, pending zawsze miałoby wartość false, bo hook czyta formularz nadrzędny, a nie ten, który komponent sam renderuje.

useActionState - pełne zarządzanie stanem akcji

useActionState (wcześniej useFormState z pakietu react-dom) to hook z pakietu react, który łączy akcję, serwerową albo zwykłą, z zarządzaniem stanem. Zwraca aktualny stan, opakowaną akcję i flagę isPending:

import { useActionState } from 'react';

// Akcja zwracająca nowy stan: tu zwykła funkcja asynchroniczna w przeglądarce
async function createMission(previousState, formData) {
  const name = formData.get('name');
  const destination = formData.get('destination');

  if (!name || name.length < 3) {
    return {
      error: 'Nazwa misji musi mieć co najmniej 3 znaki',
      success: false
    };
  }

  // Symulacja zapisu do bazy
  await new Promise(resolve => setTimeout(resolve, 1000));

  return {
    success: true,
    message: 'Misja utworzona pomyślnie!',
    missionId: Math.random().toString(36).slice(2, 11)
  };
}

function CreateMissionForm() {
  const [state, formAction, isPending] = useActionState(
    createMission,
    { error: null, success: false } // Stan początkowy
  );

  return (
    <form action={formAction}>
      <h2 style={{ color: '#00d4ff' }}>Nowa misja kosmiczna</h2>

      <input name="name" placeholder="Nazwa misji" />
      <input name="destination" placeholder="Cel podróży" />

      <button type="submit" disabled={isPending}>
        {isPending ? 'Tworzenie misji...' : 'Utwórz misję'}
      </button>

      {state.error && (
        <p style={{ color: '#ff6b6b' }}>{state.error}</p>
      )}

      {state.success && (
        <p style={{ color: '#00ff88' }}>{state.message} (ID: {state.missionId})</p>
      )}
    </form>
  );
}

Akcja dostaje poprzedni stan jako pierwszy argument, a dane formularza jako drugi. To, co zwróci, staje się nowym state, a isPending ma wartość true, dopóki akcja się nie skończy. Kolejne wysyłki React ustawia w kolejce, więc każda akcja dostaje stan zwrócony przez poprzednią.

Parametry useActionState

Hook useActionState przyjmuje trzy argumenty:

  1. action - funkcja (previousState, formData) => newState, zwykle asynchroniczna
  2. initialState - początkowy stan (dowolna wartość, najczęściej obiekt)
  3. permalink (opcjonalny) - adres strony z formularzem, potrzebny przy progressive enhancement

Zwraca tablicę z trzema elementami:

  1. state - aktualny stan (wynik ostatniej akcji albo initialState)
  2. formAction - opakowana akcja do przekazania do <form action>
  3. isPending - wartość logiczna: czy akcja jest w trakcie wykonywania

Progressive Enhancement

Jedna z największych zalet akcji formularzy to progressive enhancement: formularz może zadziałać, zanim JavaScript się załaduje. Warunek jest jeden: akcja musi być funkcją serwerową ('use server'), a strona renderowana na serwerze przez framework. Wtedy przeglądarka wyśle formularz jak zwykły formularz HTML, a serwer wykona akcję. Najpierw akcja:

// search-actions.js
'use server';

export async function searchGalaxy(previousState, formData) {
  const query = formData.get('query');
  const results = await findStars(query);
  return { results, query };
}

Komponent kliencki podaje ją do useActionState, a trzeci argument to permalink, czyli adres strony z formularzem:

// SearchForm.jsx
'use client';
import { useActionState } from 'react';
import { searchGalaxy } from './search-actions';

function SearchForm() {
  const [state, searchAction, isPending] = useActionState(
    searchGalaxy,
    { results: [], query: '' },
    '/szukaj'
  );

  return (
    <form action={searchAction}>
      <input
        name="query"
        defaultValue={state.query}
        placeholder="Szukaj gwiazd, planet, mgławic..."
      />
      <button type="submit" disabled={isPending}>
        {isPending ? 'Skanowanie...' : 'Skanuj galaktykę'}
      </button>

      {state.results.length > 0 && (
        <ul>
          {state.results.map(r => (
            <li key={r.id}>{r.name} - {r.type}</li>
          ))}
        </ul>
      )}
    </form>
  );
}

Jeśli użytkownik wyśle formularz przed hydratacją, przeglądarka przejdzie pod adres /szukaj, a serwer odeśle stronę z wynikiem. Po załadowaniu JavaScriptu React przejmuje formularz i wysyła go już bez przeładowania strony. Z akcją zapisaną jako zwykła funkcja w komponencie klienckim, jak w poprzednich przykładach, formularz zadziała dopiero po załadowaniu JavaScriptu.

Walidacja formularzy z useActionState

useActionState świetnie nadaje się do walidacji po stronie serwera z natychmiastowym komunikatem zwrotnym:

async function validateAndSubmit(prevState, formData) {
  const errors = {};

  const name = formData.get('crewName');
  const role = formData.get('role');
  const experience = parseInt(formData.get('experience'));

  if (!name || name.length < 2) errors.crewName = 'Imię musi mieć min. 2 znaki';
  if (!role) errors.role = 'Wybierz rolę';
  if (isNaN(experience) || experience < 0) errors.experience = 'Nieprawidłowe doświadczenie';

  if (Object.keys(errors).length > 0) {
    return { errors, success: false, values: { name, role, experience } };
  }

  // saveCrewMember to Twoja funkcja zapisu, np. zapytanie do bazy
  await saveCrewMember({ name, role, experience });
  return { errors: {}, success: true, message: 'Członek załogi dodany!' };
}

function CrewRegistrationForm() {
  const [state, formAction, isPending] = useActionState(
    validateAndSubmit,
    { errors: {}, success: false }
  );

  return (
    <form action={formAction}>
      <input name="crewName" defaultValue={state.values?.name || ''} />
      {state.errors?.crewName && <span style={{color:'red'}}>{state.errors.crewName}</span>}

      <select name="role" defaultValue={state.values?.role || ''}>
        <option value="">Wybierz rolę</option>
        <option value="pilot">Pilot</option>
        <option value="engineer">Inżynier</option>
        <option value="scientist">Naukowiec</option>
      </select>
      {state.errors?.role && <span style={{color:'red'}}>{state.errors.role}</span>}

      <input name="experience" type="number" defaultValue={state.values?.experience || ''} />
      {state.errors?.experience && <span style={{color:'red'}}>{state.errors.experience}</span>}

      <button type="submit" disabled={isPending}>
        {isPending ? 'Zapisywanie...' : 'Dodaj do załogi'}
      </button>

      {state.success && <p style={{color:'green'}}>{state.message}</p>}
    </form>
  );
}

Zwróć uwagę na values w odpowiedzi z błędami. Po zakończeniu akcji React resetuje formularz z niekontrolowanymi polami, a wtedy każde pole wraca do swojego defaultValue. Ponieważ defaultValue czyta wartości ze stanu, użytkownik po błędzie widzi dalej to, co wpisał, a po udanym zapisie dostaje czysty formularz.

Podsumowanie

Nowe hooki formularzy w React 19 to fundamentalna zmiana w obsłudze formularzy:

  1. useFormStatus - dostarcza informacje o stanie wysyłania formularza w komponentach potomnych
  2. useActionState - łączy akcję z zarządzaniem stanem, walidacją i progressive enhancement
  3. Server Actions - funkcje serwerowe wywoływane bezpośrednio z formularzy (we frameworku z React Server Components)
  4. Progressive Enhancement - formularz z akcją serwerową działa także przed załadowaniem JavaScript

Te hooki eliminują wiele boilerplate'u związanego z obsługą formularzy: nie potrzebujesz już ręcznego onSubmit, useState dla każdego pola ani osobnego stanu ładowania. Pamiętaj: akcja formularza to rozkaz dla centrum kontroli, a useActionState i useFormStatus meldują, na jakim etapie jest jego wykonanie.

Kod do tej lekcji: App.jsx
import { useActionState } from 'react';
import { useFormStatus } from 'react-dom';

// Akcja formularza. W Next.js mogłaby być funkcją serwerową z dyrektywą 'use server',
// tu jest zwykłą funkcją asynchroniczną, więc działa w przeglądarce.
async function submitMissionReport(previousState, formData) {
  // Symulacja opóźnienia łącza z bazą
  await new Promise(resolve => setTimeout(resolve, 1500));
  const name = formData.get('missionName');
  const dest = formData.get('destination');
  const priority = formData.get('priority');
  const values = { missionName: name, destination: dest, priority };

  // Przy błędzie zwracamy wpisane wartości: React po akcji resetuje formularz
  if (!name || name.length < 3) {
    return { ...previousState, error: 'Nazwa misji musi mieć co najmniej 3 znaki', success: false, values };
  }
  if (!dest) {
    return { ...previousState, error: 'Podaj cel misji', success: false, values };
  }

  const entry = {
    missionId: 'MSN-' + String(previousState.history.length + 1).padStart(3, '0'),
    message: `Misja "${name}" do ${dest} (priorytet: ${priority}) utworzona!`
  };
  // Historia rośnie z akcji na akcję, bo akcja dostaje poprzedni stan
  return { error: null, success: true, values: {}, ...entry, history: [entry, ...previousState.history] };
}

// Przycisk czyta stan formularza przez useFormStatus, bez żadnych propsów
function SubmitButton() {
  const { pending } = useFormStatus();
  return (
    <button
      type="submit"
      disabled={pending}
      style={{
        width: '100%', padding: '12px', marginTop: '12px',
        background: pending ? '#1a2a3c' : 'linear-gradient(135deg, #00d4ff, #0088cc)',
        color: pending ? '#556677' : '#0a0e17',
        border: 'none', borderRadius: '8px', cursor: pending ? 'wait' : 'pointer',
        fontSize: '14px', fontWeight: 'bold', transition: 'all 0.3s',
      }}
    >
      {pending ? 'Transmisja w toku...' : 'Wyślij raport misji'}
    </button>
  );
}

// Pole samo blokuje się w czasie wysyłki formularza
function MissionInput({ name, label, placeholder, type = 'text', defaultValue }) {
  const { pending } = useFormStatus();
  const fieldStyle = {
    width: '100%', padding: '10px 12px', background: '#0f1729',
    color: '#e0e1dd', border: '1px solid #2a3a5c', borderRadius: '6px',
    opacity: pending ? 0.5 : 1, boxSizing: 'border-box',
  };
  return (
    <div style={{ marginBottom: '12px' }}>
      <label htmlFor={name} style={{ color: '#8892b0', fontSize: '12px', display: 'block', marginBottom: '4px' }}>
        {label}
      </label>
      {type === 'select' ? (
        <select id={name} name={name} defaultValue={defaultValue || 'medium'} disabled={pending} style={fieldStyle}>
          <option value="high">Wysoki</option>
          <option value="medium">Średni</option>
          <option value="low">Niski</option>
        </select>
      ) : (
        <input id={name} name={name} placeholder={placeholder} defaultValue={defaultValue || ''} disabled={pending} style={fieldStyle} />
      )}
    </div>
  );
}

// Nakładka widoczna tylko w czasie wysyłki
function LoadingOverlay() {
  const { pending } = useFormStatus();
  if (!pending) return null;
  return (
    <div style={styles.overlay}>
      <div style={styles.spinner} />
      <p style={{ color: '#00d4ff', marginTop: '10px', fontSize: '13px' }}>Przesyłanie do bazy...</p>
    </div>
  );
}

function MissionHistory({ missions }) {
  if (missions.length === 0) return null;
  return (
    <div style={styles.history}>
      <h3 style={{ color: '#00d4ff', fontSize: '14px', margin: '0 0 10px' }}>Historia misji</h3>
      {missions.map((m) => (
        <div key={m.missionId} style={styles.historyItem}>
          <span style={styles.missionId}>{m.missionId}</span>
          <span>{m.message}</span>
        </div>
      ))}
    </div>
  );
}

function App() {
  const [state, formAction] = useActionState(submitMissionReport, {
    error: null, success: false, values: {}, history: []
  });

  return (
    <div style={styles.container}>
      <header style={styles.header}>
        <h1 style={styles.title}>Centrum Dowodzenia Misji</h1>
        <p style={styles.subtitle}>useFormStatus i useActionState - hooki formularzy React 19</p>
      </header>

      <div style={styles.grid}>
        <div style={styles.formPanel}>
          <h2 style={{ color: '#00d4ff', fontSize: '16px', margin: '0 0 16px' }}>
            Nowa misja kosmiczna
          </h2>

          <form action={formAction}>
            <LoadingOverlay />
            <MissionInput name="missionName" label="Nazwa misji" placeholder="Np. Eksploracja Proxima b" defaultValue={state.values.missionName} />
            <MissionInput name="destination" label="Cel podróży" placeholder="Np. Alpha Centauri" defaultValue={state.values.destination} />
            <MissionInput name="priority" label="Priorytet" type="select" defaultValue={state.values.priority} />
            <SubmitButton />
          </form>

          {state.error && (
            <div role="alert" style={styles.error}>
              <span style={{ marginRight: '8px' }}>!</span> {state.error}
            </div>
          )}
          {state.success && (
            <div style={styles.success}>
              <span style={{ marginRight: '8px' }}>OK</span> {state.message}
              <div style={{ fontSize: '11px', color: '#00aa66', marginTop: '4px' }}>
                ID: {state.missionId}
              </div>
            </div>
          )}
        </div>

        <MissionHistory missions={state.history} />
      </div>

      <div style={styles.info}>
        <h3 style={{ color: '#ffd700', fontSize: '13px', margin: '0 0 8px' }}>Jak to działa:</h3>
        <ul style={{ margin: 0, paddingLeft: '20px', fontSize: '12px', color: '#8892b0' }}>
          <li>useActionState łączy akcję ze stanem i zwraca [state, formAction, isPending]</li>
          <li>useFormStatus w przycisku, polach i nakładce czyta stan wysyłki formularza</li>
          <li>Akcja dostaje poprzedni stan i FormData z polami formularza</li>
          <li>Po akcji React resetuje pola, dlatego przy błędzie wracają przez defaultValue</li>
        </ul>
      </div>
    </div>
  );
}

const styles = {
  container: { fontFamily: 'system-ui', background: '#0a0e17', color: '#e0e1dd', minHeight: '100vh', padding: '20px' },
  header: { textAlign: 'center', marginBottom: '20px' },
  title: { fontSize: '22px', color: '#00d4ff', margin: '0 0 4px' },
  subtitle: { fontSize: '12px', color: '#8892b0', margin: 0 },
  grid: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '16px', maxWidth: '800px', margin: '0 auto' },
  formPanel: { background: 'rgba(0,212,255,0.05)', borderRadius: '10px', padding: '20px', border: '1px solid rgba(0,212,255,0.15)', position: 'relative', overflow: 'hidden' },
  overlay: { position: 'absolute', top: 0, left: 0, right: 0, bottom: 0, background: 'rgba(10,14,23,0.85)', display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', zIndex: 10, borderRadius: '10px' },
  spinner: { width: '30px', height: '30px', border: '3px solid #1a3a5c', borderTopColor: '#00d4ff', borderRadius: '50%', animation: 'spin 1s linear infinite' },
  error: { marginTop: '12px', padding: '10px 14px', background: 'rgba(255,107,107,0.1)', border: '1px solid rgba(255,107,107,0.3)', borderRadius: '6px', color: '#ff6b6b', fontSize: '13px' },
  success: { marginTop: '12px', padding: '10px 14px', background: 'rgba(0,255,136,0.08)', border: '1px solid rgba(0,255,136,0.3)', borderRadius: '6px', color: '#00ff88', fontSize: '13px' },
  history: { background: 'rgba(0,212,255,0.05)', borderRadius: '10px', padding: '16px', border: '1px solid rgba(0,212,255,0.15)' },
  historyItem: { display: 'flex', gap: '8px', padding: '8px 10px', background: 'rgba(0,0,0,0.3)', borderRadius: '6px', marginBottom: '6px', fontSize: '12px', alignItems: 'center' },
  missionId: { padding: '2px 8px', background: 'rgba(0,212,255,0.2)', borderRadius: '4px', color: '#00d4ff', fontSize: '10px', fontWeight: 'bold', whiteSpace: 'nowrap' },
  info: { maxWidth: '800px', margin: '20px auto 0', padding: '14px', background: 'rgba(255,215,0,0.05)', border: '1px solid rgba(255,215,0,0.15)', borderRadius: '8px' },
};

export default App;

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Gdzie musi być używany hook useFormStatus, aby prawidłowo odczytywać stan formularza?

  2. 2. Jakie trzy wartości zwraca hook useActionState?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    W pliku App.jsx jest formularz raportu misji i asynchroniczna akcja sendReport, która sprawdza nazwę misji i po pół sekundy odpowiada jak baza na Ziemi. Uzupełnij luki: ___BLANK1___ to metoda FormData, która odczytuje wartość pola po jego nazwie, ___BLANK2___ to hook Reacta 19, który łączy akcję ze stanem formularza i zwraca [state, formAction, isPending], ___BLANK3___ to atrybut elementu <form>, do którego przekazujesz formAction, a ___BLANK4___ to wartość, która blokuje przycisk na czas wysyłania. Nazwa krótsza niż 3 znaki ma pokazać komunikat błędu, a poprawna potwierdzenie z nazwą misji. Wyślij formularz w podglądzie i sprawdź oba przypadki.

  • Klikanie w kolejności

    Ułóż poprawną składnię wywołania useActionState:

  • Klikanie w kolejności

    Ułóż poprawną składnię formularza z Server Action:

  • Edytor kodu

    W pliku App.jsx jest formularz rejestracji członka załogi (pola name, role i experience) oraz akcja registerCrewMember, która sprawdza dane po stronie „serwera” i zwraca obiekt errors z komunikatem dla każdego złego pola. Uzupełnij luki: ___BLANK1___ to warunek prawdziwy, gdy imię values.name ma mniej niż 2 znaki, ___BLANK2___ to obiekt z wpisanymi wartościami, który akcja zwraca razem z błędami, a ___BLANK3___ to klucz w state.errors z komunikatem dla pola roli. React po zakończeniu akcji czyści pola formularza, dlatego defaultValue przywraca je ze stanu. Błędne dane mają pokazać osobny komunikat przy każdym złym polu i zostawić wpisane wartości, a poprawne powitanie z imieniem.

  1. PytanieHook useFormStatus
  2. PytanieParametry useActionState
  3. Zadanie z kodemPraktyka: Formularz misji kosmicznej
  4. PytanieServer Actions - dyrektywa
  5. Kliknij w kolejnościWywołanie useActionState
  6. Kliknij w kolejnościAtrybut action w formularzu
  7. Zadanie z kodemPraktyka: Walidacja formularza z useActionState

Przydatne artykuły