eduardweb.
Hooks & PatternsAvansat#typescript#react#frontend#design-patterns

Cum scrii un Accordion flexibil: de la props hell la Compound Components

De Răzvan Matei, 17 nov. 2026 · 10 vizualizări · 2 like-uri

Postat acum 4 zile
typescript
import { createContext, useContext, useState, ReactNode } from "react";

type AccordionContextType = {
  active: string | null;
  toggle: (val: string) => void;
};

const AccordionCtx = createContext<AccordionContextType | null>(null);
const ItemCtx = createContext<{ value: string } | null>(null);

export function Accordion({ children }: { children: ReactNode }) {
  const [active, setActive] = useState<string | null>(null);
  const toggle = (val: string) => setActive((prev) => (prev === val ? null : val));

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

export function AccordionItem({ value, children }: { value: string; children: ReactNode }) {
  return <ItemCtx.Provider value={{ value }}>{children}</ItemCtx.Provider>;
}

export function AccordionTrigger({ children }: { children: ReactNode }) {
  const item = useContext(ItemCtx);
  const accordion = useContext(AccordionCtx);
  if (!item || !accordion) throw new Error("Trigger must be in AccordionItem");

  const isOpen = accordion.active === item.value;
  return (
    <button 
      type="button"
      onClick={() => accordion.toggle(item.value)}
      aria-expanded={isOpen}
      className="flex w-full justify-between p-4 font-medium"
    >
      {children}
    </button>
  );
}

Dacă ai prins o componentă de Accordion într-un design system intern, știi groaza: începe cu trei props și ajunge la cincisprezece într-un an. isCollapsible, renderCustomHeader, headerRightIcon, hideBorderOnMobile și alte minuni care transformă codul într-o ciorbă de if-uri.

Am pățit asta direct acum doi ani, pe un dashboard B2B cu vreo 60 de ecrane. Aveam un <Accordion items={data} /> clasic pe care îl foloseau vreo 8 devi. De fiecare dată când un designer schimba un amărât de badge din dreapta titlului în stânga lui, cineva mai adăuga un prop opțional sau un render function. La un moment dat, componenta avea 14 props și 400 de linii de logică doar pentru layout.

Soluția pe care o folosesc de atunci peste tot este pattern-ul de compound components. E aceeași filozofie pe care o vezi în Radix UI sau Headless UI: lași consumatorul să decidă structura din DOM, iar tu gestionezi doar starea comună.

Cum împarți responsabilitățile

În loc de un singur monolit, spargi totul în 4 bucăți mici: Accordion (rădăcina), AccordionItem, AccordionTrigger și AccordionContent. Ele comunică exclusiv prin React Context. Consumatorul nici măcar nu trebuie să știe că acel context există.

Rădăcina ține minte care element e deschis (un string sau un array dacă permiți expand multiplu). Trigger-ul doar emite evenimentul de toggle și setează atributele ARIA corecte (aria-expanded, aria-controls). Content-ul verifică dacă value-ul părinte este activ; dacă nu, se ascunde sau se demontează.

Ce câștigi din asta? Flexibilitate completă. Dacă designerul vrea brusc un buton de acțiune secundară în header, îl pui pur și simplu în JSX lângă AccordionTrigger. Nu modifici componenta de bază, nu adaugi props, nu riști să strici alte 30 de locuri unde e folosită.

Trade-off-uri de care nu-ți zice nimeni

Sună perfect, dar vine cu niște compromisuri reale:

  1. Mai mult cod de scris la consum. Pentru fiecare instanță scrii 4 tag-uri JSX în loc de unul singur cu un array de obiecte. Dacă ai liste uriașe dinamice unde toate rândurile sunt identice, s-ar putea ca un wrapper peste compound component să fie mai practic.
  2. Risc de runtime errors la layout. Fiindcă subcomponentele depind de Context-ul din rădăcină, dacă un junior pune un <AccordionTrigger> în afara unui <AccordionItem>, crapă la runtime. Trebuie să arunci mereu erori explicite în custom hook-uri (useAccordionItemContext must be used within an AccordionItem).
  3. Gestionarea animațiilor devine tricky. Când content-ul se demontează complet din DOM, nu mai poți face tranziții fluide pe înălțime cu CSS simplu fără să recurgi la trick-uri de calcul de scrollHeight sau librării ca Framer Motion.

La un proiect serios, libertatea de compunere bate aproape mereu boilerplate-ul suplimentar. Voi folosiți compound components în design system-ul propriu sau preferați în continuare abordarea data-driven cu props?

Răspunsuri 0

Se încarcă răspunsurile…

Loghează-te pentru a răspunde

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