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:
- 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ă.
- Risc de HTML invalid: dacă un junior trântește un
<div>aiurea întreAccordionșiAccordionItem, compoziția poate funcționa tehnic prin context, dar strici accesibilitatea (WAI-ARIA) dacă nu ai grijă la atributelearia-expandedșiaria-controls. - 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?