Patrones de Componentes de UI
Cuándo usar esta skill
- Construcción de Bibliotecas de Componentes: Creación de componentes de UI reutilizables
- Implementación de Sistemas de Diseño: Aplicación de patrones de UI consistentes
- UI Compleja: Componentes que requieren múltiples variantes (Botón, Modal, Desplegable)
- Refactorización: Extracción de código duplicado en componentes
Instrucciones
Paso 1: Diseño de la API de Props
Diseña Props que sean fáciles de usar y extensibles.
Principios:
- Nombres claros
- Valores predeterminados razonables
- Definiciones de tipo con TypeScript
- Props opcionales usan el marcador opcional (?)
Ejemplo (Botón):
interface ButtonProps {
// Requerido
children: React.ReactNode;
// Opcional (con valores predeterminados)
variant?: 'primary' | 'secondary' | 'outline' | 'ghost';
size?: 'sm' | 'md' | 'lg';
disabled?: boolean;
isLoading?: boolean;
// Manejadores de eventos
onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
// Herencia de atributos HTML
type?: 'button' | 'submit' | 'reset';
className?: string;
}
function Button({
children,
variant = 'primary',
size = 'md',
disabled = false,
isLoading = false,
onClick,
type = 'button',
className = '',
...rest
}: ButtonProps) {
const baseClasses = 'btn';
const variantClasses = `btn-${variant}`;
const sizeClasses = `btn-${size}`;
const classes = `${baseClasses} ${variantClasses} ${sizeClasses} ${className}`;
return (
<button
type={type}
className={classes}
disabled={disabled || isLoading}
onClick={onClick}
{...rest}
>
{isLoading ? <Spinner /> : children}
</button>
);
}
// Ejemplo de uso
<Button variant="primary" size="lg" onClick={() => alert('¡Clickeado!')}>
Clickéame
</Button>
Paso 2: Patrón de Composición
Combina componentes pequeños para construir UI compleja.
Ejemplo (Tarjeta):
// Componente Card (Contenedor)
interface CardProps {
children: React.ReactNode;
className?: string;
}
function Card({ children, className = '' }: CardProps) {
return <div className={`card ${className}`}>{children}</div>;
}
// Card.Header
function CardHeader({ children }: { children: React.ReactNode }) {
return <div className="card-header">{children}</div>;
}
// Card.Body
function CardBody({ children }: { children: React.ReactNode }) {
return <div className="card-body">{children}</div>;
}
// Card.Footer
function CardFooter({ children }: { children: React.ReactNode }) {
return <div className="card-footer">{children}</div>;
}
// Patrón de Componente Compuesto
Card.Header = CardHeader;
Card.Body = CardBody;
Card.Footer = CardFooter;
export default Card;
// Uso
import Card from './Card';
function ProductCard() {
return (
<Card>
<Card.Header>
<h3>Nombre del Producto</h3>
</Card.Header>
<Card.Body>
<img src="..." alt="Producto" />
<p>Descripción del producto aquí...</p>
</Card.Body>
<Card.Footer>
<button>Añadir al Carrito</button>
</Card.Footer>
</Card>
);
}
Paso 3: Render Props / Children como Función
Un patrón para personalización flexible.
Ejemplo (Desplegable):
interface DropdownProps<T> {
items: T[];
renderItem: (item: T, index: number) => React.ReactNode;
onSelect: (item: T) => void;
placeholder?: string;
}
function Dropdown<T>({ items, renderItem, onSelect, placeholder }: DropdownProps<T>) {
const [isOpen, setIsOpen] = useState(false);
const [selected, setSelected] = useState<T | null>(null);
const handleSelect = (item: T) => {
setSelected(item);
onSelect(item);
setIsOpen(false);
};
return (
<div className="dropdown">
<button onClick={() => setIsOpen(!isOpen)}>
{selected ? renderItem(selected, -1) : placeholder || 'Seleccionar...'}
</button>
{isOpen && (
<ul className="dropdown-menu">
{items.map((item, index) => (
<li key={index} onClick={() => handleSelect(item)}>
{renderItem(item, index)}
</li>
))}
</ul>
)}
</div>
);
}
// Uso
interface User {
id: string;
name: string;
avatar: string;
}
function UserDropdown() {
const users: User[] = [...];
return (
<Dropdown
items={users}
placeholder="Selecciona un usuario"
renderItem={(user) => (
<div className="user-item">
<img src={user.avatar} alt={user.name} />
<span>{user.name}</span>
</div>
)}
onSelect={(user) => console.log('Seleccionado:', user)}
/>
);
}
Paso 4: Separando la Lógica con Custom Hooks
Separa la UI de la lógica de negocio.
Ejemplo (Modal):
// hooks/useModal.ts
function useModal(initialOpen = false) {
const [isOpen, setIsOpen] = useState(initialOpen);
const open = useCallback(() => setIsOpen(true), []);
const close = useCallback(() => setIsOpen(false), []);
const toggle = useCallback(() => setIsOpen(prev => !prev), []);
return { isOpen, open, close, toggle };
}
// components/Modal.tsx
interface ModalProps {
isOpen: boolean;
onClose: () => void;
title: string;
children: React.ReactNode;
}
function Modal({ isOpen, onClose, title, children }: ModalProps) {
if (!isOpen) return null;
return (
<div className="modal-overlay" onClick={onClose}>
<div className="modal-content" onClick={(e) => e.stopPropagation()}>
<div className="modal-header">
<h2>{title}</h2>
<button onClick={onClose} aria-label="Cerrar">×</button>
</div>
<div className="modal-body">{children}</div>
</div>
</div>
);
}
// Uso
function App() {
const { isOpen, open, close } = useModal();
return (
<>
<button onClick={open}>Abrir Modal</button>
<Modal isOpen={isOpen} onClose={close} title="Mi Modal">
<p>Contenido del modal aquí...</p>
</Modal>
</>
);
}
Paso 5: Optimización del Rendimiento
Previene re-renderizados innecesarios.
React.memo:
// ❌ Malo: el hijo se re-renderiza cada vez que el padre lo hace
function ExpensiveComponent({ data }) {
console.log('Renderizando...');
return <div>{/* UI compleja */}</div>;
}
// ✅ Bueno: se re-renderiza solo cuando cambian las props
const ExpensiveComponent = React.memo(({ data }) => {
console.log('Renderizando...');
return <div>{/* UI compleja */}</div>;
});
useMemo y useCallback:
function ProductList({ products, category }: { products: Product[]; category: string }) {
// ✅ Memorizar resultados filtrados
const filteredProducts = useMemo(() => {
return products.filter(p => p.category === category);
}, [products, category]);
// ✅ Memorizar callback
const handleAddToCart = useCallback((productId: string) => {
// Añadir al carrito
console.log('Añadiendo:', productId);
}, []);
return (
<div>
{filteredProducts.map(product => (
<ProductCard
key={product.id}
product={product}
onAddToCart={handleAddToCart}
/>
))}
</div>
);
}
const ProductCard = React.memo(({ product, onAddToCart }) => {
return (
<div>
<h3>{product.name}</h3>
<button onClick={() => onAddToCart(product.id)}>Añadir al Carrito</button>
</div>
);
});
Formato de salida
Estructura de Archivos de Componentes
components/
├── Button/
│ ├── Button.tsx # Componente principal
│ ├── Button.test.tsx # Pruebas
│ ├── Button.stories.tsx # Storybook
│ ├── Button.module.css # Estilos
│ └── index.ts # Exportación
├── Card/
│ ├── Card.tsx
│ ├── CardHeader.tsx
│ ├── CardBody.tsx
│ ├── CardFooter.tsx
│ └── index.ts
└── Modal/
├── Modal.tsx
├── useModal.ts # Custom hook
└── index.ts
Plantilla de Componente
import React from 'react';
export interface ComponentProps {
// Definición de props
children: React.ReactNode;
className?: string;
}
/**
* Descripción del componente
*
* @example
* ```tsx
* <Component>Hola</Component>
* ```
*/
export const Component = React.forwardRef<HTMLDivElement, ComponentProps>(
({ children, className = '', ...rest }, ref) => {
return (
<div ref={ref} className={`component ${className}`} {...rest}>
{children}
</div>
);
}
);
Component.displayName = 'Component';
export default Component;
Restricciones
Reglas Requeridas (DEBE)
-
Principio de Responsabilidad Única: Un componente tiene un solo rol
- Button maneja solo botones, Form maneja solo formularios
-
Definición de Tipo de Props: Interfaz de TypeScript requerida
- Habilita el autocompletado
- Seguridad de tipos
-
Accesibilidad: aria-*, role, tabindex, etc.
Reglas Prohibidas (NO DEBE)
-
Excesivo prop drilling: Prohibido cuando hay 5+ niveles de profundidad
- Usar Context o Composición
-
Sin Lógica de Negocio: Prohibir llamadas a API y cálculos complejos en componentes de UI
- Separar en custom hooks
-
Objetos/funciones en línea: Degradación del rendimiento
// ❌ Ejemplo malo <Component style={{ color: 'red' }} onClick={() => handleClick()} /> // ✅ Ejemplo bueno const style = { color: 'red' }; const handleClick = useCallback(() => {...}, []); <Component style={style} onClick={handleClick} />
Ejemplos
Ejemplo 1: Acordeón (Componente Compuesto)
import React, { createContext, useContext, useState } from 'react';
// Compartir estado con Context
const AccordionContext = createContext<{
activeIndex: number | null;
setActiveIndex: (index: number | null) => void;
} | null>(null);
function Accordion({ children }: { children: React.ReactNode }) {
const [activeIndex, setActiveIndex] = useState<number | null>(null);
return (
<AccordionContext.Provider value={{ activeIndex, setActiveIndex }}>
<div className="accordion">{children}</div>
</AccordionContext.Provider>
);
}
function AccordionItem({ index, title, children }: {
index: number;
title: string;
children: React.ReactNode;
}) {
const context = useContext(AccordionContext);
if (!context) throw new Error('AccordionItem debe usarse dentro de Accordion');
const { activeIndex, setActiveIndex } = context;
const isActive = activeIndex === index;
return (
<div className="accordion-item">
<button
className="accordion-header"
onClick={() => setActiveIndex(isActive ? null : index)}
aria-expanded={isActive}
>
{title}
</button>
{isActive && <div className="accordion-body">{children}</div>}
</div>
);
}
Accordion.Item = AccordionItem;
export default Accordion;
// Uso
<Accordion>
<Accordion.Item index={0} title="Sección 1">
Contenido para la sección 1
</Accordion.Item>
<Accordion.Item index={1} title="Sección 2">
Contenido para la sección 2
</Accordion.Item>
</Accordion>
Ejemplo 2: Componente Polimórfico (prop as)
type PolymorphicComponentProps<C extends React.ElementType> = {
as?: C;
children: React.ReactNode;
} & React.ComponentPropsWithoutRef<C>;
function Text<C extends React.ElementType = 'span'>({
as,
children,
...rest
}: PolymorphicComponentProps<C>) {
const Component = as || 'span';
return <Component {...rest}>{children}</Component>;
}
// Uso
<Text>Span por defecto</Text>
<Text as="h1">Encabezado 1</Text>
<Text as="p" style={{ color: 'blue' }}>Párrafo</Text>
<Text as={Link} href="/about">Enlace</Text>
Mejores prácticas
- Composición sobre Props: Aprovecha children en lugar de muchas props
- Controlado vs No Controlado: Elige según la situación
- Props por Defecto: Proporciona valores predeterminados razonables
- Storybook: Documentación y desarrollo de componentes
Referencias
- React Patterns
- Componentes Compuestos
- Radix UI - Componentes accesibles
- Chakra UI - Biblioteca de componentes
- shadcn/ui - Componentes copiables
Metadatos
Versión
- Versión Actual: 1.0.0
- Última Actualización: 2025-01-01
- Plataformas Compatibles: Claude, ChatGPT, Gemini
Skills Relacionadas
- web-accessibility: Componentes accesibles
- state-management: Gestión de estado de componentes
Etiquetas
#UI-components #React #design-patterns #composition #TypeScript #frontend