Cette fiche concentre les concepts CSS et Tailwind indispensables pour tes projets React et React Native. Organisée pour une consultation rapide, elle contient les patterns les plus utilisés avec des exemples TypeScript concrets.
Points essentiels à retenir:
- Box Model : Comprendre content, padding, border, margin
- Flexbox : Layout unidimensionnel parfait pour les composants React
- Grid : Layout bidimensionnel pour structures complexes
- Tailwind Utilities : Classes prêtes à l'emploi pour accélérer le développement
- Responsive : Mobile-first approach avec breakpoints
- Animations : Micro-interactions et transitions fluides
- Dark Mode : Thèmes adaptatifs avec Tailwind
Box Model CSS
Le Box Model est la fondation de tout layout CSS. Chaque élément HTML est une boîte rectangulaire composée de quatre zones concentriques qui déterminent l'espace occupé.
Exemple d'implémentation TypeScript React - Box Model en action
// Interface pour les props du composant
interface CardProps {
children: React.ReactNode;
variant?: 'default' | 'compact';
}
const Card: React.FC<CardProps> = ({ children, variant = 'default' }) => (
<div className={`
// Content: définit la zone de contenu
w-64 h-32
// Padding: espacement interne
${variant === 'compact' ? 'p-3' : 'p-6'}
// Border: bordure visible
border-2 border-gray-200 rounded-lg
// Margin: espacement externe
m-4
// Background pour visualiser le content + padding
bg-white
`}>
{children}
</div>
);
// Usage avec box-sizing
const PreciseCard: React.FC = () => (
<div className="box-border w-64 p-6 border-4">
{/* Largeur finale = exactement 256px (w-64) */}
{/* Padding et border inclus dans les 256px */}
</div>
);
Référence rapide Box Model
- •
box-sizing: border-box→ Padding et border inclus dans width - •
box-sizing: content-box→ Width = contenu seulement (défaut) - • Tailwind:
box-borderoubox-content
Flexbox - Layout Unidimensionnel
Flexbox excelle pour organiser des éléments dans une seule direction (ligne ou colonne). Parfait pour les barres de navigation, les boutons alignés, ou les composants cards en ligne.
- display: flex
- flex-direction: row | column
- justify-content: center | space-between
- align-items: center | stretch
- flex-wrap: wrap | nowrap
- gap: 1rem
- flex-grow: 1 (grandir)
- flex-shrink: 0 (ne pas rétrécir)
- flex-basis: 200px (taille de base)
- flex: 1 0 auto (raccourci)
- align-self: center
- order: 2
Pattern Navigation React avec Flexbox
interface NavItem {
label: string;
href: string;
icon?: React.ReactNode;
}
const Navigation: React.FC<{ items: NavItem[] }> = ({ items }) => (
<nav className="
flex // Active flexbox
justify-between // Logo à gauche, menu à droite
items-center // Alignement vertical centré
px-6 py-4 // Espacement interne
bg-white shadow-sm // Style visuel
">
<div className="flex items-center space-x-2">
<Logo />
<span className="font-bold text-xl">MonApp</span>
</div>
<div className="
flex // Menu horizontal
space-x-6 // Espacement entre items (gap-6)
items-center // Alignement vertical
">
{items.map((item, index) => (
<a
key={index}
href={item.href}
className="
flex items-center space-x-1 // Icon + texte alignés
px-3 py-2 // Zone cliquable
rounded-md // Style
hover:bg-gray-100 // Interaction
transition-colors // Animation fluide
"
>
{item.icon}
<span>{item.label}</span>
</a>
))}
</div>
</nav>
);
// Usage : Centrage parfait d'un modal
const Modal: React.FC<{ children: React.ReactNode }> = ({ children }) => (
<div className="
fixed inset-0 // Occupe tout l'écran
flex // Active flexbox
items-center // Centre verticalement
justify-center // Centre horizontalement
bg-black bg-opacity-50 // Overlay sombre
">
<div className="bg-white rounded-lg p-6 max-w-md w-full mx-4">
{children}
</div>
</div>
);
CSS Grid - Layout Bidimensionnel
CSS Grid excelle pour créer des layouts complexes avec lignes et colonnes. Idéal pour les structures de page, les galeries d'images, ou les dashboards.
Exemple d'implémentation - Layout de Page React avec CSS Grid
// Interface pour la structure de page
interface PageLayoutProps {
header: React.ReactNode;
sidebar: React.ReactNode;
main: React.ReactNode;
aside?: React.ReactNode;
footer: React.ReactNode;
}
const PageLayout: React.FC<PageLayoutProps> = ({
header, sidebar, main, aside, footer
}) => (
<div className="
min-h-screen // Hauteur minimum écran complet
grid // Active CSS Grid
grid-cols-[250px_1fr_200px] // 3 colonnes : fixe, flexible, fixe
grid-rows-[80px_1fr_60px] // 3 lignes : header, contenu, footer
gap-4 // Espacement entre zones
" style={{
gridTemplateAreas: `
'header header header'
'sidebar main aside'
'footer footer footer'
`
}}>
<header className="bg-blue-600 text-white p-4" style={{ gridArea: 'header' }}>
{header}
</header>
<nav className="bg-gray-100 p-4" style={{ gridArea: 'sidebar' }}>
{sidebar}
</nav>
<main className="bg-white p-6" style={{ gridArea: 'main' }}>
{main}
</main>
{aside && (
<aside className="bg-gray-50 p-4" style={{ gridArea: 'aside' }}>
{aside}
</aside>
)}
<footer className="bg-gray-800 text-white p-4" style={{ gridArea: 'footer' }}>
{footer}
</footer>
</div>
);
// Galerie responsive avec auto-fit
const ImageGallery: React.FC<{ images: string[] }> = ({ images }) => (
<div className="
grid
grid-cols-[repeat(auto-fit,minmax(300px,1fr))] // Colonnes automatiques
gap-6 // Espacement uniforme
p-6
">
{images.map((src, index) => (
<img
key={index}
src={src}
className="w-full h-64 object-cover rounded-lg shadow-md"
alt={`Image ${index + 1}`}
/>
))}
</div>
);
Tailwind CSS Utilities
Tailwind transforme l'écriture CSS avec ses classes utilitaires. Au lieu d'écrire du CSS personnalisé, tu composes des classes atomiques pour construire tes interfaces rapidement.
| Catégorie | Classes Essentielles | Équivalent CSS | Cas d'usage React |
|---|---|---|---|
| Spacing |
p-4, px-6, py-2m-3, mx-auto, mt-8space-x-4, gap-6
|
padding: 1remmargin: 0 autogap: 1.5rem
|
Espacement dans composants cards, formulaires, navigation |
| Colors |
bg-blue-500, text-gray-700border-red-300, hover:bg-blue-600
|
background: #3b82f6color: #374151
|
Boutons, badges de statut, messages d'erreur |
| Typography |
text-xl, font-boldleading-relaxed, tracking-wide
|
font-size: 1.25remline-height: 1.625
|
Titres, paragraphes, labels de formulaires |
| Layout |
flex, grid, hiddenabsolute, relative
|
display: flexposition: absolute
|
Structures de composants, positionnement d'éléments |
Exemple d'implémentation - Composant Button Complet avec Tailwind
interface ButtonProps {
variant: 'primary' | 'secondary' | 'danger';
size: 'sm' | 'md' | 'lg';
disabled?: boolean;
loading?: boolean;
children: React.ReactNode;
onClick?: () => void;
}
const Button: React.FC<ButtonProps> = ({
variant,
size,
disabled = false,
loading = false,
children,
onClick
}) => {
// Classes de base communes
const baseClasses = `
inline-flex items-center justify-center
font-medium rounded-md
transition-all duration-200
focus:outline-none focus:ring-2 focus:ring-offset-2
disabled:opacity-50 disabled:cursor-not-allowed
`;
// Classes selon la variante
const variantClasses = {
primary: `
bg-blue-600 text-white
hover:bg-blue-700 active:bg-blue-800
focus:ring-blue-500
`,
secondary: `
bg-gray-200 text-gray-900
hover:bg-gray-300 active:bg-gray-400
focus:ring-gray-500
`,
danger: `
bg-red-600 text-white
hover:bg-red-700 active:bg-red-800
focus:ring-red-500
`
};
// Classes selon la taille
const sizeClasses = {
sm: 'px-3 py-1.5 text-sm',
md: 'px-4 py-2 text-base',
lg: 'px-6 py-3 text-lg'
};
return (
<button
className={`
${baseClasses}
${variantClasses[variant]}
${sizeClasses[size]}
${loading ? 'cursor-wait' : ''}
`}
disabled={disabled || loading}
onClick={onClick}
>
{loading && (
<svg
className="animate-spin -ml-1 mr-2 h-4 w-4"
fill="none"
viewBox="0 0 24 24"
>
<circle
cx="12" cy="12" r="10"
stroke="currentColor"
strokeWidth="4"
className="opacity-25"
/>
<path
fill="currentColor"
d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
className="opacity-75"
/>
</svg>
)}
{children}
</button>
);
};
// Usage dans un composant
const App: React.FC = () => (
<div className="p-8 space-y-4">
<Button variant="primary" size="md" onClick={() => console.log('Clicked')}>
Valider
</Button>
<Button variant="danger" size="sm" loading>
Suppression...
</Button>
</div>
);
Responsive Design Mobile-First
L'approche mobile-first consiste à concevoir d'abord pour les petits écrans, puis ajouter des améliorations pour les écrans plus larges. Cette méthode garantit une expérience optimale sur tous les appareils.
Référence rapide - Breakpoints Tailwind (Mobile-First)
- • Défaut : 0px → Mobile (styles de base)
- •
sm:640px → Petit tablet - •
md:768px → Tablet - •
lg:1024px → Desktop - •
xl:1280px → Large desktop - •
2xl:1536px → Extra large
Exemple d'implémentation - Hook TypeScript pour la Détection de Breakpoint
import { useState, useEffect } from 'react';
type Breakpoint = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
interface BreakpointConfig {
sm: number;
md: number;
lg: number;
xl: number;
'2xl': number;
}
const breakpoints: BreakpointConfig = {
sm: 640,
md: 768,
lg: 1024,
xl: 1280,
'2xl': 1536
};
export const useBreakpoint = () => {
const [currentBreakpoint, setCurrentBreakpoint] = useState<Breakpoint>('sm');
useEffect(() => {
const checkBreakpoint = () => {
const width = window.innerWidth;
if (width >= breakpoints['2xl']) setCurrentBreakpoint('2xl');
else if (width >= breakpoints.xl) setCurrentBreakpoint('xl');
else if (width >= breakpoints.lg) setCurrentBreakpoint('lg');
else if (width >= breakpoints.md) setCurrentBreakpoint('md');
else setCurrentBreakpoint('sm');
};
// Vérification initiale
checkBreakpoint();
// Écouter les changements de taille
window.addEventListener('resize', checkBreakpoint);
return () => window.removeEventListener('resize', checkBreakpoint);
}, []);
return {
current: currentBreakpoint,
isSmUp: currentBreakpoint !== 'sm',
isMdUp: ['md', 'lg', 'xl', '2xl'].includes(currentBreakpoint),
isLgUp: ['lg', 'xl', '2xl'].includes(currentBreakpoint),
isXlUp: ['xl', '2xl'].includes(currentBreakpoint)
};
};
// Composant utilisant le hook
const ResponsiveComponent: React.FC = () => {
const { current, isMdUp, isLgUp } = useBreakpoint();
return (
<div className={`
// Mobile-first : colonnes simples
grid grid-cols-1 gap-4 p-4
// Tablet : 2 colonnes
md:grid-cols-2 md:gap-6 md:p-6
// Desktop : 3 colonnes avec plus d'espace
lg:grid-cols-3 lg:gap-8 lg:p-8
// Large desktop : 4 colonnes
xl:grid-cols-4
`}>
{/* Affichage conditionnel basé sur le breakpoint */}
{isLgUp && (
<div className="col-span-full bg-blue-50 p-4 rounded-lg">
<h2>Bannière visible uniquement sur desktop</h2>
</div>
)}
{/* Navigation adaptive */}
<nav className={`
${isMdUp
? 'flex space-x-6'
: 'fixed bottom-0 left-0 right-0 bg-white border-t flex justify-around py-2'
}
`}>
<a href="#" className="flex items-center space-x-2">
<HomeIcon />
{isMdUp && <span>Accueil</span>}
</a>
{/* Autres liens... */}
</nav>
<p className="text-sm text-gray-500">
Breakpoint actuel : {current}
</p>
</div>
);
};
- hidden md:block (masquer sur mobile)
- block md:hidden (masquer sur desktop)
- text-sm md:text-base lg:text-lg
- p-4 md:p-6 lg:p-8
- grid-cols-1 md:grid-cols-2 lg:grid-cols-3
- flex-col md:flex-row
- Mobile: Menu hamburger
- Tablet: Menu horizontal
- Desktop: Menu étendu
- Sidebar: hidden lg:block
- Bottom nav: block md:hidden
Performance et Optimisations
L'optimisation CSS est cruciale pour les performances, surtout en React où les styles peuvent impacter le rendu. Voici les techniques essentielles pour maintenir des applications rapides.
Exemple d'implémentation - Configuration Tailwind Optimisée pour Production
// tailwind.config.js - Configuration optimisée
module.exports = {
// Purging : supprime les classes CSS non utilisées
content: [
'./src/**/*.{js,jsx,ts,tsx}', // Scan tous les fichiers React
'./public/index.html',
// Inclure les bibliothèques si elles utilisent Tailwind
'./node_modules/@your-company/ui-components/**/*.{js,ts,jsx,tsx}'
],
// Mode JIT (Just-In-Time) pour génération à la demande
mode: 'jit',
theme: {
extend: {
// Variables CSS custom pour cohérence
colors: {
brand: {
50: '#eff6ff',
100: '#dbeafe',
500: '#3b82f6',
600: '#2563eb',
900: '#1e3a8a'
}
},
// Espacement personnalisé
spacing: {
'18': '4.5rem',
'88': '22rem'
},
// Breakpoints personnalisés si nécessaire
screens: {
'xs': '475px',
'3xl': '1600px'
}
}
},
plugins: [
// Plugins essentiels pour forms et typography
require('@tailwindcss/forms'),
require('@tailwindcss/typography')
]
};
// PostCSS config pour optimisations
// postcss.config.js
module.exports = {
plugins: [
require('tailwindcss'),
require('autoprefixer'),
// Optimisations pour production
...(process.env.NODE_ENV === 'production'
? [
require('cssnano')({
preset: 'default'
})
]
: []
)
]
};
Exemple d'implémentation - Styles Conditionnels Performants avec clsx
import clsx from 'clsx';
import { memo } from 'react';
// ✅ Bon : Classes statiques et logique simple
interface BadgeProps {
variant: 'success' | 'warning' | 'error';
size: 'sm' | 'md';
children: React.ReactNode;
}
const Badge = memo<BadgeProps>(({ variant, size, children }) => {
return (
<span className={clsx(
// Classes de base (toujours présentes)
'inline-flex items-center font-medium rounded-full',
// Classes conditionnelles basées sur variant
{
'bg-green-100 text-green-800': variant === 'success',
'bg-yellow-100 text-yellow-800': variant === 'warning',
'bg-red-100 text-red-800': variant === 'error'
},
// Classes conditionnelles basées sur size
{
'px-2 py-1 text-xs': size === 'sm',
'px-3 py-1.5 text-sm': size === 'md'
}
)}>
{children}
</span>
);
});
// ❌ Éviter : Calculs complexes dans le className
const BadBadge: React.FC<BadgeProps> = ({ variant, size, children }) => (
<span className={`
${getComplexVariantStyles(variant)} // ← Calcul coûteux à chaque render
${theme.spacing[calculateSpacing(size)]} // ← Accès objet complexe
${Math.random() > 0.5 ? 'animate-pulse' : ''} // ← Logique non déterministe
`}>
{children}
</span>
);
// Pattern pour styles complexes : useMemo
const ComplexComponent: React.FC<{ data: any[] }> = ({ data }) => {
const containerClasses = useMemo(() => clsx(
'grid gap-4',
{
'grid-cols-1': data.length <= 3,
'grid-cols-2': data.length > 3 && data.length <= 6,
'grid-cols-3': data.length > 6
}
), [data.length]); // ← Recalcul seulement si data.length change
return <div className={containerClasses}>{/* ... */}</div>;
};
Checklist Performance CSS
- • Purging : Configurer correctement le content dans tailwind.config.js
- • Critical CSS : Inliner le CSS critique pour le first paint
- • Code splitting : Lazy load des styles non critiques
- • Memoization : useMemo pour les calculs de classes complexes
- • Bundle analysis : Vérifier la taille finale du CSS
Animations et Transitions
Les animations bien utilisées améliorent l'expérience utilisateur en guidant l'attention et en donnant vie aux interfaces. Tailwind propose des classes pour les transitions courantes, et React offre des bibliothèques puissantes pour les animations complexes.
- aspect-ratio: 16/9 (ratio d'aspect)
- object-fit: cover | contain
- object-position: center
- overflow: hidden | auto | scroll
- overflow-x: hidden
- overflow-y: auto
- transition-all (toutes propriétés)
- transition-colors (couleurs)
- transition-transform (transformations)
- duration-300 (300ms)
- ease-in-out (courbe d'animation)
- delay-150 (délai de 150ms)
Exemple d'implémentation - Micro-interactions avec Tailwind
// Composant Card avec animations au hover
interface AnimatedCardProps {
title: string;
description: string;
imageUrl: string;
onClick?: () => void;
}
const AnimatedCard: React.FC<AnimatedCardProps> = ({
title, description, imageUrl, onClick
}) => (
<div
className="
group bg-white rounded-xl shadow-md overflow-hidden
transition-all duration-300 ease-out cursor-pointer
hover:shadow-xl hover:scale-105 hover:-translate-y-2
active:scale-95
"
onClick={onClick}
>
<div className="aspect-video overflow-hidden">
<img
src={imageUrl}
alt={title}
className="
w-full h-full object-cover
group-hover:scale-110 transition-transform duration-500
"
/>
</div>
<div className="p-6">
<h3 className="
text-xl font-semibold text-gray-800 mb-2
group-hover:text-blue-600 transition-colors duration-200
">
{title}
</h3>
<p className="
text-gray-600 text-sm leading-relaxed
group-hover:text-gray-800 transition-colors duration-200 delay-75
">
{description}
</p>
<div className="
mt-4 flex items-center text-blue-600
group-hover:translate-x-2 transition-transform duration-200
">
<span className="text-sm font-medium">En savoir plus</span>
<svg className="w-4 h-4 ml-1" fill="currentColor" viewBox="0 0 20 20">
<path fillRule="evenodd" d="M10.293 3.293a1 1 0 011.414 0l6 6a1 1 0 010 1.414l-6 6a1 1 0 01-1.414-1.414L14.586 11H3a1 1 0 110-2h11.586l-4.293-4.293a1 1 0 010-1.414z" clipRule="evenodd" />
</svg>
</div>
</div>
</div>
);
// Hook pour gérer les animations d'apparition
const useInView = (threshold = 0.1) => {
const [isInView, setIsInView] = useState(false);
const ref = useRef<HTMLDivElement>(null);
useEffect(() => {
const observer = new IntersectionObserver(
([entry]) => setIsInView(entry.isIntersecting),
{ threshold }
);
if (ref.current) observer.observe(ref.current);
return () => observer.disconnect();
}, [threshold]);
return { ref, isInView };
};
// Composant avec animation d'apparition
const FadeInSection: React.FC<{ children: React.ReactNode }> = ({ children }) => {
const { ref, isInView } = useInView(0.2);
return (
<div
ref={ref}
className={`
transition-all duration-700 ease-out
${isInView
? 'opacity-100 translate-y-0'
: 'opacity-0 translate-y-8'
}
`}
>
{children}
</div>
);
};
// Animation avec Framer Motion (bibliothèque externe)
import { motion } from 'framer-motion';
const MotionButton: React.FC = () => (
<motion.button
className="px-6 py-3 bg-blue-600 text-white rounded-lg"
whileHover={{
scale: 1.05,
boxShadow: "0 10px 25px rgba(0,0,0,0.2)"
}}
whileTap={{ scale: 0.95 }}
transition={{
type: "spring",
stiffness: 300,
damping: 20
}}
>
Bouton animé
</motion.button>
);
// Liste avec animations séquentielles
const AnimatedList: React.FC<{ items: string[] }> = ({ items }) => (
<motion.ul
initial="hidden"
animate="visible"
variants={{
hidden: { opacity: 0 },
visible: {
opacity: 1,
transition: {
staggerChildren: 0.1 // Délai entre chaque enfant
}
}
}}
className="space-y-2"
>
{items.map((item, index) => (
<motion.li
key={index}
variants={{
hidden: { opacity: 0, x: -20 },
visible: { opacity: 1, x: 0 }
}}
className="p-3 bg-white rounded-lg shadow-sm"
>
{item}
</motion.li>
))}
</motion.ul>
);
Référence rapide - Classes d'animation Tailwind
- •
animate-spin: Rotation continue (loading spinners) - •
animate-ping: Pulsation avec agrandissement - •
animate-pulse: Fade in/out (skeleton loading) - •
animate-bounce: Rebond vertical - •
hover:animate-wiggle: Animation au hover (custom)
Dark Mode avec Tailwind
Le mode sombre améliore l'expérience utilisateur, surtout dans des environnements peu éclairés. Tailwind facilite l'implémentation avec des classes conditionnelles et une configuration simple.
Exemple d'implémentation - Configuration et Hook Dark Mode
// tailwind.config.js - Configuration pour dark mode
module.exports = {
darkMode: 'class', // Activation via classe CSS
content: ['./src/**/*.{js,jsx,ts,tsx}'],
theme: {
extend: {
colors: {
// Couleurs personnalisées pour le dark mode
dark: {
50: '#f8fafc',
100: '#f1f5f9',
200: '#e2e8f0',
800: '#1e293b',
900: '#0f172a'
}
}
}
}
};
// Hook pour gérer le dark mode
const useDarkMode = () => {
const [isDark, setIsDark] = useState(() => {
// Vérifier la préférence système ou le stockage local
if (typeof window !== 'undefined') {
const stored = localStorage.getItem('darkMode');
if (stored) return JSON.parse(stored);
return window.matchMedia('(prefers-color-scheme: dark)').matches;
}
return false;
});
useEffect(() => {
const root = document.documentElement;
if (isDark) {
root.classList.add('dark');
} else {
root.classList.remove('dark');
}
// Sauvegarder la préférence
localStorage.setItem('darkMode', JSON.stringify(isDark));
}, [isDark]);
const toggle = () => setIsDark(!isDark);
return { isDark, toggle };
};
// Composant Toggle pour le dark mode
const DarkModeToggle: React.FC = () => {
const { isDark, toggle } = useDarkMode();
return (
<button
onClick={toggle}
className="
p-2 rounded-lg transition-all duration-200
bg-gray-200 hover:bg-gray-300
dark:bg-gray-700 dark:hover:bg-gray-600
text-gray-700 dark:text-gray-200
"
aria-label={isDark ? 'Activer le mode clair' : 'Activer le mode sombre'}
>
{isDark ? (
<svg className="w-5 h-5" fill="currentColor" viewBox="0 0 20 20">
<path fillRule="evenodd" d="M10 2a1 1 0 011 1v1a1 1 0 11-2 0V3a1 1 0 011-1zm4 8a4 4 0 11-8 0 4 4 0 018 0zm-.464 4.95l.707.707a1 1 0 001.414-1.414l-.707-.707a1 1 0 00-1.414 1.414zm2.12-10.607a1 1 0 010 1.414l-.706.707a1 1 0 11-1.414-1.414l.707-.707a1 1 0 011.414 0zM17 11a1 1 0 100-2h-1a1 1 0 100 2h1zm-7 4a1 1 0 011 1v1a1 1 0 11-2 0v-1a1 1 0 011-1zM5.05 6.464A1 1 0 106.465 5.05l-.708-.707a1 1 0 00-1.414 1.414l.707.707zm1.414 8.486l-.707.707a1 1 0 01-1.414-1.414l.707-.707a1 1 0 011.414 1.414zM4 11a1 1 0 100-2H3a1 1 0 000 2h1z" clipRule="evenodd" />
</svg>
) : (
<svg className="w-5 h-5" fill="currentColor" viewBox="0 0 20 20">
<path d="M17.293 13.293A8 8 0 016.707 2.707a8.001 8.001 0 1010.586 10.586z" />
</svg>
)}
</button>
);
};
// Exemple de composant avec support dark mode
const ThemedCard: React.FC<{ children: React.ReactNode }> = ({ children }) => (
<div className="
bg-white dark:bg-gray-800
text-gray-900 dark:text-gray-100
border border-gray-200 dark:border-gray-700
rounded-lg shadow-sm dark:shadow-lg
p-6 transition-colors duration-200
">
{children}
</div>
);
Patterns React + Tailwind Avancés25 min
Ces patterns combinent la puissance de React avec l'efficacité de Tailwind pour créer des composants réutilisables et maintenables.
Système de Design avec Variants
// types/ui.ts - Types pour le système de design
export type ColorVariant = 'primary' | 'secondary' | 'success' | 'warning' | 'error';
export type SizeVariant = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
export type RoundedVariant = 'none' | 'sm' | 'md' | 'lg' | 'full';
// utils/classVariants.ts - Utilitaire pour gérer les variants
interface VariantConfig<T extends string> {
[key: string]: Record<T, string>;
}
export const createVariants = <T extends string>(config: VariantConfig<T>) => {
return (selectedVariants: Partial<Record<keyof typeof config, T>>) => {
return Object.entries(selectedVariants)
.map(([key, value]) => config[key]?.[value as T])
.filter(Boolean)
.join(' ');
};
};
// Configuration des variants
const buttonVariants = createVariants({
variant: {
primary: 'bg-blue-600 text-white hover:bg-blue-700',
secondary: 'bg-gray-200 text-gray-900 hover:bg-gray-300',
success: 'bg-green-600 text-white hover:bg-green-700',
warning: 'bg-yellow-500 text-white hover:bg-yellow-600',
error: 'bg-red-600 text-white hover:bg-red-700'
},
size: {
xs: 'px-2 py-1 text-xs',
sm: 'px-3 py-1.5 text-sm',
md: 'px-4 py-2 text-base',
lg: 'px-6 py-3 text-lg',
xl: 'px-8 py-4 text-xl'
},
rounded: {
none: 'rounded-none',
sm: 'rounded-sm',
md: 'rounded-md',
lg: 'rounded-lg',
full: 'rounded-full'
}
});
// Composant Button avec système de variants
interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
variant?: ColorVariant;
size?: SizeVariant;
rounded?: RoundedVariant;
loading?: boolean;
leftIcon?: React.ReactNode;
rightIcon?: React.ReactNode;
}
export const Button: React.FC<ButtonProps> = ({
variant = 'primary',
size = 'md',
rounded = 'md',
loading = false,
leftIcon,
rightIcon,
children,
className,
disabled,
...props
}) => {
const variantClasses = buttonVariants({ variant, size, rounded });
return (
<button
className={clsx(
// Classes de base
'inline-flex items-center justify-center',
'font-medium transition-all duration-200',
'focus:outline-none focus:ring-2 focus:ring-offset-2',
'disabled:opacity-50 disabled:cursor-not-allowed',
// Variants
variantClasses,
// Loading state
loading && 'cursor-wait',
// Classes custom
className
)}
disabled={disabled || loading}
{...props}
>
{loading && (
<Spinner className={clsx(
'animate-spin',
size === 'xs' && 'w-3 h-3',
size === 'sm' && 'w-4 h-4',
size === 'md' && 'w-4 h-4',
size === 'lg' && 'w-5 h-5',
size === 'xl' && 'w-6 h-6',
(leftIcon || children) && 'mr-2'
)} />
)}
{!loading && leftIcon && (
<span className="mr-2">{leftIcon}</span>
)}
{children}
{!loading && rightIcon && (
<span className="ml-2">{rightIcon}</span>
)}
</button>
);
};
// Usage du composant
const ExampleUsage: React.FC = () => (
<div className="space-y-4 p-6">
<Button
variant="primary"
size="lg"
leftIcon={<SaveIcon />}
onClick={() => console.log('Saved!')}
>
Enregistrer
</Button>
<Button
variant="error"
size="sm"
rounded="full"
loading
>
Suppression...
</Button>
</div>
);
À Retenir
- Box Model : Maîtrise content, padding, border, margin. Utilise
box-sizing: border-boxpour des dimensions prévisibles. Temps d'apprentissage : 5 minutes de mémorisation - Flexbox : Parfait pour layouts unidimensionnels (navigation, alignements). Properties essentielles :
justify-content,align-items,flex-grow. Temps de pratique : 15 minutes - CSS Grid : Idéal pour layouts bidimensionnels complexes. Utilise
grid-template-areaspour des structures lisibles. Temps d'apprentissage : 20 minutes - Tailwind Utilities : Classes atomiques pour développement rapide. Système cohérent : spacing (multiples de 4px), couleurs (50-950), breakpoints mobile-first. Apprentissage : 10 minutes par jour
- Responsive Design : Approche mobile-first avec breakpoints Tailwind. Hook personnalisé pour logique conditionnelle. Configuration : 15 minutes
- Performance : Configuration Tailwind avec purging, optimisation bundle CSS, memoization des classes complexes. Setup : 20 minutes
- Patterns Avancés : Système de variants pour composants réutilisables, types TypeScript stricts, composition avec clsx. Implémentation : 25 minutes
- Best Practices : Éviter les calculs coûteux dans className, privilégier les classes statiques, utiliser memo() pour les composants stylisés complexes
Total temps d'apprentissage estimé : ~1h50 pour maîtriser l'essentiel CSS/Tailwind en React.
Cette fiche te donne les 80% des concepts que tu utiliseras quotidiennement. Garde-la sous la main et consulte-la régulièrement pour solidifier tes réflexes CSS/Tailwind !