eduardweb.
Hooks & PatternsAvansat#architecture#typescript#react#frontend

Compound components în React: cum construiești un Accordion flexibil

De Alin Pătrașcu, 18 oct. 2026 · 34 vizualizări · 3 like-uri

Postat 18 oct. 2026
typescript
import React, { createContext, useContext, useState } from "react";

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

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

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

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

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

export function AccordionTrigger({ children }: { children: React.ReactNode }) {
  const acc = useContext(AccordionContext);
  const item = useContext(ItemContext);
  if (!acc || !item) throw new Error("Trigger-ul trebuie utilizat în interiorul AccordionItem");

  const isOpen = acc.active === item.value;
  return (
    <button
      type="button"
      onClick={() => acc.toggle(item.value)}
      aria-expanded={isOpen}
      className="flex w-full justify-between py-2 text-left font-medium"
    >
      {children}
      <span className="transition-transform duration-200">{isOpen ? "−" : "+"}</span>
    </button>
  );
}

export function AccordionContent({ children }: { children: React.ReactNode }) {
  const acc = useContext(AccordionContext);
  const item = useContext(ItemContext);
  if (!acc || !item) throw new Error("Content-ul trebuie utilizat în interiorul AccordionItem");

  if (acc.active !== item.value) return null;
  return <div className="pb-3 pt-1 text-sm text-zinc-600">{children}</div>;
}

Toți am scris la un moment dat o componentă de tip <Accordion items={data} />. Pare curat în prima zi, dar peste trei luni vine un coleg de la produs și-ți cere un badge pe al doilea rând, o iconiță diferită pe al treilea și un buton de acțiune în header-ul secțiunii deschise.

În clipa aia începe calvarul prop-urilor opționale: renderCustomHeader, headerClassName, badgeVariantByIndex, hideArrowOnSpecificItem. Am pățit asta la o platformă B2B cu vreo 14 dashboard-uri, unde un banal panou de setări a transformat un accordion de 60 de linii într-un monstru de 400 de linii plin de if-uri.

Soluția pe care o folosesc și cei de la Radix sau shadcn/ui este modelul de compound components. Împarți logica în bucăți independente care comunică discret prin Context, lăsând consumatorul să dicteze structura DOM-ului.

De ce pică modelul clasic pe bază de array

Când forțezi datele într-un array de obiecte, transformi o structură UI într-un contract de date rigid. React iubește compoziția, nu configurarea masivă.

Dacă ai nevoie de o animație la expandare sau vrei să randezi un tooltip lângă titlu, cu un array devine un coșmar de render props. Cu componente compuse, markup-ul redevine HTML nativ în feeling:

<Accordion> gestionează starea (care item e deschis, dacă e single sau multiple), iar copiii (AccordionItem, AccordionTrigger, AccordionContent) doar consumă starea aia.

Mecanica: Context discret și slot-uri implicite

Avem două niveluri de context: unul rădăcină (pentru starea globală a accordion-ului) și unul per item (ca trigger-ul și conținutul să știe la ce valoare răspund fără să pasezi id-ul manual peste tot).

În implementarea de mai jos, useAccordion asigură că nimeni nu aruncă un AccordionTrigger prin pagină în afara părintelui. Dacă cineva uită contextul, primește o eroare curată la runtime, nu un ecran alb cu undefined is not an object.

Trade-off-ul sincer: flexibilitate vs strictețe

Nu există soluție gratis în frontend. Modelul ăsta vine cu compromisuri clare:

  1. Mai mult boilerplate pentru consumator: dacă vrei doar o listă banală de 3 FAQ-uri, scrii 15 linii de JSX în loc de una singură.
  2. Risc de HTML invalid: dacă un junior trântește un <div> aiurea între Accordion și AccordionItem, compoziția poate funcționa tehnic prin context, dar strici accesibilitatea (WAI-ARIA) dacă nu ai grijă la atributele aria-expanded și aria-controls.
  3. Re-render-uri necontrolate: dacă bagi tot state-ul într-un context generic fără memoizare la value, schimbarea unui tab va re-randa toate trigger-ele din pagină. La 5 items nu pasă nimănui; la un panou cu 80 de filtre dinamice începi să simți lag pe mobile.

Compound components merită efortul când construiești librării interne sau bucăți de UI cu cerințe vizuale imprevizibile. Dacă interfața e bătută în cuie pentru următorii doi ani, un simplu array mapat e de zece ori mai rapid de livrat.

Voi la ce componentă ați regretat cel mai mult că n-ați mers pe compoziție încă de la început?

Răspunsuri 0

Se încarcă răspunsurile…

Loghează-te pentru a răspunde

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