CSS & Tailwind – Fiche Mémo Essentielle

Préparation entretien technique : navigation, état, hooks, performances et bonnes pratiques React Native.

frontend

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é.

Margin (externe) Border Padding (interne) Content Largeur totale = content + padding + border + margin

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-border ou box-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.

Propriétés du Conteneur (Parent)
  • display: flex
  • flex-direction: row | column
  • justify-content: center | space-between
  • align-items: center | stretch
  • flex-wrap: wrap | nowrap
  • gap: 1rem
Propriétés des Enfants
  • 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.

CSS Grid Container Header (grid-column: 1 / 4) Sidebar Main Aside Footer (grid-column: 1 / 4)

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-2
m-3, mx-auto, mt-8
space-x-4, gap-6
padding: 1rem
margin: 0 auto
gap: 1.5rem
Espacement dans composants cards, formulaires, navigation
Colors bg-blue-500, text-gray-700
border-red-300, hover:bg-blue-600
background: #3b82f6
color: #374151
Boutons, badges de statut, messages d'erreur
Typography text-xl, font-bold
leading-relaxed, tracking-wide
font-size: 1.25rem
line-height: 1.625
Titres, paragraphes, labels de formulaires
Layout flex, grid, hidden
absolute, relative
display: flex
position: 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>
);
};
          
Patterns Responsive Courants
  • 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
Navigation Responsive
  • 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.

Propriétés CSS essentielles
  • aspect-ratio: 16/9 (ratio d'aspect)
  • object-fit: cover | contain
  • object-position: center
  • overflow: hidden | auto | scroll
  • overflow-x: hidden
  • overflow-y: auto
Transitions Tailwind
  • 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-box pour 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-areas pour 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 !