eduardweb.
Hooks & PatternsAvansat#typescript#shadcn#react#compound-components#web-accessibility

Compound components în React: cum am scăpat de 14 props într-un Accordion

De Bogdan Răducanu, 31 oct. 2026 · 20 vizualizări · 2 like-uri

Postat 31 oct. 2026
typescript
import React, { createContext, useContext, useState, useId } from 'react';

type AccordionContextType = {
  activeItem: string | null;
  toggleItem: (value: string) => void;
};

const AccordionContext = createContext<AccordionContextType | null>(null);
const ItemContext = createContext<string | null>(null);

export function Accordion({ children }: { children: React.ReactNode }) {
  const [activeItem, setActiveItem] = useState<string | null>(null);
  const toggleItem = (value: string) => setActiveItem(prev => (prev === value ? null : value));

  return (
    <AccordionContext.Provider value={{ activeItem, toggleItem }}>
      <div className="divide-y border rounded-md">{children}</div>
    </AccordionContext.Provider>
  );
}

export function AccordionItem({ value, children }: { value: string; children: React.ReactNode }) {
  return <ItemContext.Provider value={value}><div className="p-2">{children}</div></ItemContext.Provider>;
}

export function AccordionTrigger({ children }: { children: React.ReactNode }) {
  const ctx = useContext(AccordionContext);
  const value = useContext(ItemContext);
  if (!ctx || !value) throw new Error('Trigger used outside Item/Accordion');

  return (
    <button type="button" onClick={() => ctx.toggleItem(value)} className="w-full flex justify-between font-medium py-2">
      {children}
    </button>
  );
}

export function AccordionContent({ children }: { children: React.ReactNode }) {
  const ctx = useContext(AccordionContext);
  const value = useContext(ItemContext);
  if (ctx?.activeItem !== value) return null;

  return <div className="py-2 text-sm text-gray-600">{children}</div>;
}

Acum trei ani aveam în producție un <Accordion /> cu 14 props-uri opționale. Totul a început nevinovat cu items={[{ title, content }]}, dar în timp au apărut renderRightIcon, titleClassName, keepMounted, defaultIndex și alte improvizații care făceau codul de negăsit. Când un designer a cerut un badge animat lângă titlu doar pe al treilea rând, am realizat că arhitectura mea era complet blocată.

Soluția sănătoasă pe care o folosesc acum de fiecare dată este pattern-ul de compound components, identic cu ce găsiți în Radix UI sau shadcn/ui. Ideea de bază e simplă: componenta părinte ține starea și logica, iar copiii își împart responsabilitățile fără să pasezi date manual între ei.

De ce pică modelul clasic bazat pe obiecte

Când pasezi o listă de obiecte într-un singur tag, îți asumi că știi dinainte cum va arăta fiecare bucată de UI. Nu știi. În realitate, un client vrea un buton de „Export PDF” direct în header-ul secțiunii, altul vrea ca textul din interior să se încarce prin streaming, iar altul vrea să ascundă săgeata de expandare.

Dacă ai un monolit, adaugi props noi pentru fiecare excepție. Dacă ai componente compuse, lași consumatorul să decidă structura DOM exact ca în HTML nativ cu <select> și <option>:

<Accordion type="single">
  <AccordionItem value="item-1">
    <AccordionTrigger>Setări profil</AccordionTrigger>
    <AccordionContent>Formularul tău aici...</AccordionContent>
  </AccordionItem>
</Accordion>

Context intern și accesibilitate fără dureri de cap

Secretul din spate este împărțirea pe două niveluri de context React. Ai nevoie de un context general la nivel de <Accordion> (care știe ce valoare e deschisă și dacă permitem selecție multiplă) și de un context local în fiecare <AccordionItem> (care memorează valoarea specifică acelui nod și generează ID-uri unice pentru atributele WAI-ARIA).

Fără ID-uri legate între aria-controls pe buton și aria-labelledby pe panou, accesibilitatea e praf. Generând un id stabil cu useId() direct în AccordionItem, consumatorul componentei nu trebuie să-și bată capul cu ele deloc.

Evitați capcana din vechiul React de a folosi React.Children.map și React.cloneElement. Pattern-ul acela injecta props ascunse direct în copii direcți și se rupea imediat ce cineva punea un <div> intermediar pentru styling. Contextul funcționează indiferent de adâncimea nodurilor în arbore.

Trade-off-uri sincere: ce pierzi când alegi asta

Nu există soluție perfectă în inginerie. La un proiect enterprise cu vreo 40k utilizatori activi lunar, am rescris toate componentele mari pe stilul ăsta. Numărul de PR-uri pentru mici modificări de UI pe filtre a scăzut cu aproape 60%, pentru că developerii nu mai modificau componenta de bază, ci doar compuneau subcomponentele după bunul plac.

Dar prețul e clar: ai mai mult boilerplate inițial. E mai mult cod de scris la prima tastare decât un simplu items.map(). În al doilea rând, consumatorul API-ului are libertatea să greșească ordinea: poate pune din greșeală <AccordionContent> înaintea lui <AccordionTrigger>, iar dacă nu ai mesaje clare de eroare în dev mode când lipsește contextul, vei petrece timp explicând de ce nu se deschide panoul.

Merge brici pentru biblioteci interne de design system și interfețe dinamice. E o pierdere de timp pentru un FAQ banal de 3 întrebări de pe un landing page static.

Voi mai scrieți componente monolitice cu liste de configurație sau ați trecut complet pe compunere cu context?

Răspunsuri 0

Se încarcă răspunsurile…

Loghează-te pentru a răspunde

Doar membrii comunității pot lăsa comentarii.