Patterns de Composants UI
Quand utiliser ce skill
- Création de bibliothèques de composants : Créer des composants d'interface réutilisables
- Implémentation de systèmes de design : Appliquer des patterns d'interface cohérents
- UI complexe : Composants nécessitant plusieurs variantes (Bouton, Modale, Menu déroulant)
- Refactorisation : Extraire le code dupliqué en composants
Instructions
Étape 1 : Conception de l'API des Props
Concevoir des props faciles à utiliser et extensibles.
Principes :
- Noms clairs
- Valeurs par défaut raisonnables
- Définitions de types avec TypeScript
- Les Props optionnelles utilisent le marqueur optionnel (?)
Exemple (Bouton) :
interface ButtonProps {
// Requis
children: React.ReactNode;
// Optionnel (avec valeurs par défaut)
variant?: 'primary' | 'secondary' | 'outline' | 'ghost';
size?: 'sm' | 'md' | 'lg';
disabled?: boolean;
isLoading?: boolean;
// Gestionnaires d'événements
onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
// Héritage des attributs 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>
);
}
// Exemple d'utilisation
<Button variant="primary" size="lg" onClick={() => alert('Cliqué !')}>
Cliquez-moi
</Button>
Étape 2 : Pattern de Composition
Combiner de petits composants pour construire une UI complexe.
Exemple (Carte) :
// Composant Carte (Conteneur)
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>;
}
// Pattern de composant composé
Card.Header = CardHeader;
Card.Body = CardBody;
Card.Footer = CardFooter;
export default Card;
// Utilisation
import Card from './Card';
function ProductCard() {
return (
<Card>
<Card.Header>
<h3>Nom du Produit</h3>
</Card.Header>
<Card.Body>
<img src="..." alt="Produit" />
<p>Description du produit ici...</p>
</Card.Body>
<Card.Footer>
<button>Ajouter au Panier</button>
</Card.Footer>
</Card>
);
}
Étape 3 : Render Props / Enfants en tant que Fonction
Un pattern pour une personnalisation flexible.
Exemple (Menu déroulant) :
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 || 'Sélectionner...'}
</button>
{isOpen && (
<ul className="dropdown-menu">
{items.map((item, index) => (
<li key={index} onClick={() => handleSelect(item)}>
{renderItem(item, index)}
</li>
))}
</ul>
)}
</div>
);
}
// Utilisation
interface User {
id: string;
name: string;
avatar: string;
}
function UserDropdown() {
const users: User[] = [...];
return (
<Dropdown
items={users}
placeholder="Sélectionner un utilisateur"
renderItem={(user) => (
<div className="user-item">
<img src={user.avatar} alt={user.name} />
<span>{user.name}</span>
</div>
)}
onSelect={(user) => console.log('Sélectionné :', user)}
/>
);
}
Étape 4 : Séparation de la Logique avec des Hooks Personnalisés
Séparer l'UI de la logique métier.
Exemple (Modale) :
// 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="Fermer">×</button>
</div>
<div className="modal-body">{children}</div>
</div>
</div>
);
}
// Utilisation
function App() {
const { isOpen, open, close } = useModal();
return (
<>
<button onClick={open}>Ouvrir la Modale</button>
<Modal isOpen={isOpen} onClose={close} title="Ma Modale">
<p>Contenu de la modale ici...</p>
</Modal>
</>
);
}
Étape 5 : Optimisation des Performances
Éviter les re-rendus inutiles.
React.memo :
// ❌ Mauvais : l'enfant se re-rend à chaque re-rendu du parent
function ExpensiveComponent({ data }) {
console.log('Rendu...');
return <div>{/* UI complexe */}</div>;
}
// ✅ Bon : se re-rend uniquement lorsque les props changent
const ExpensiveComponent = React.memo(({ data }) => {
console.log('Rendu...');
return <div>{/* UI complexe */}</div>;
});
useMemo & useCallback :
function ProductList({ products, category }: { products: Product[]; category: string }) {
// ✅ Mémoïser les résultats filtrés
const filteredProducts = useMemo(() => {
return products.filter(p => p.category === category);
}, [products, category]);
// ✅ Mémoïser le callback
const handleAddToCart = useCallback((productId: string) => {
// Ajouter au panier
console.log('Ajout :', 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)}>Ajouter au Panier</button>
</div>
);
});
Format de sortie
Structure de Fichier du Composant
components/
├── Button/
│ ├── Button.tsx # Composant principal
│ ├── Button.test.tsx # Tests
│ ├── Button.stories.tsx # Storybook
│ ├── Button.module.css # Styles
│ └── index.ts # Export
├── Card/
│ ├── Card.tsx
│ ├── CardHeader.tsx
│ ├── CardBody.tsx
│ ├── CardFooter.tsx
│ └── index.ts
└── Modal/
├── Modal.tsx
├── useModal.ts # Hook personnalisé
└── index.ts
Modèle de Composant
import React from 'react';
export interface ComponentProps {
// Définition des props
children: React.ReactNode;
className?: string;
}
/**
* Description du composant
*
* @example
* ```tsx
* <Component>Bonjour</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;
Contraintes
Règles Requises (DOIT)
-
Principe de Responsabilité Unique : Un composant a un seul rôle
- Button gère uniquement les boutons, Form gère uniquement les formulaires
-
Définition de Type des Props : Interface TypeScript requise
- Active l'auto-complétion
- Sécurité de type
-
Accessibilité : aria-*, role, tabindex, etc.
Règles Interdites (NE DOIT PAS)
-
Drilling de props excessif : Interdit à 5 niveaux ou plus de profondeur
- Utiliser Context ou Composition
-
Pas de Logique Métier : Interdire les appels API et les calculs complexes dans les composants UI
- Séparer dans des hooks personnalisés
-
Objets/fonctions en ligne : Dégradation des performances
// ❌ Mauvais exemple <Component style={{ color: 'red' }} onClick={() => handleClick()} /> // ✅ Bon exemple const style = { color: 'red' }; const handleClick = useCallback(() => {...}, []); <Component style={style} onClick={handleClick} />
Exemples
Exemple 1 : Accordéon (Composant Composé)
import React, { createContext, useContext, useState } from 'react';
// Partager l'état avec 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 doit être utilisé à l\'intérieur d\'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;
// Utilisation
<Accordion>
<Accordion.Item index={0} title="Section 1">
Contenu de la section 1
</Accordion.Item>
<Accordion.Item index={1} title="Section 2">
Contenu de la section 2
</Accordion.Item>
</Accordion>
Exemple 2 : Composant Polymorphe (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>;
}
// Utilisation
<Text>Par défaut span</Text>
<Text as="h1">Titre 1</Text>
<Text as="p" style={{ color: 'blue' }}>Paragraphe</Text>
<Text as={Link} href="/about">Lien</Text>
Bonnes pratiques
- Composition plutôt que Props : Utiliser les enfants plutôt que de nombreuses props
- Contrôlé vs Non contrôlé : Choisir en fonction de la situation
- Props par défaut : Fournir des valeurs par défaut raisonnables
- Storybook : Documentation et développement des composants
Références
- React Patterns
- Compound Components
- Radix UI - Composants accessibles
- Chakra UI - Bibliothèque de composants
- shadcn/ui - Composants copier-coller
Métadonnées
Version
- Version actuelle : 1.0.0
- Dernière mise à jour : 2025-01-01
- Plateformes compatibles : Claude, ChatGPT, Gemini
Compétences connexes
- web-accessibility : Composants accessibles
- state-management : Gestion d'état des composants
Tags
#UI-components #React #design-patterns #composition #TypeScript #frontend