Communitygithub.com

ComeOnOliver/skillshub

Construisez des composants d'interface réutilisables et maintenables en suivant des modèles de conception modernes. À utiliser lors de la création de bibliothèques de composants, de l'implémentation de systèmes de design ou de la construction d'architectures frontend évolutives. Gère les patterns React, la composition, la conception des props, TypeScript et les bonnes pratiques des composants.

Qu'est-ce que skillshub ?

Ce skill fournit aux développeurs un guide structuré pour créer des composants d'interface utilisateur réutilisables en React/TypeScript. Il couvre les fondamentaux de la conception de composants, allant de la définition des props et de la composition à l'optimisation des performances. Le skill présente des patterns clés comme les composants composés (Card, Accordéon), les render props (Dropdown) et la séparation de la logique métier via des hooks personnalisés (utilisation de modale). Il met l'accent sur les bonnes pratiques comme le principe de responsabilité unique, l'accessibilité (ARIA) et l'utilisation de `React.memo`, `useMemo` et `useCallback`. Il inclut également des exemples de composants polymorphes et des règles strictes sur ce qu'il faut éviter (drilling de props excessif, logique métier dans les composants UI). Les développeurs l'utilisent pour créer des bibliothèques de composants cohérentes, évolutives et performantes compatibles avec des outils comme Storybook, Radix UI et Chakra UI.

Compatible avec✓Claude Code~Codex CLI~Cursor✓Gemini CLI
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/aiskillstore/marketplace/supercent-io/ui-component-patterns

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Aperçu

Depuis le README du skill

skillshub preview

Documentation

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)

  1. Principe de Responsabilité Unique : Un composant a un seul rôle

    • Button gère uniquement les boutons, Form gère uniquement les formulaires
  2. Définition de Type des Props : Interface TypeScript requise

    • Active l'auto-complétion
    • Sécurité de type
  3. Accessibilité : aria-*, role, tabindex, etc.

Règles Interdites (NE DOIT PAS)

  1. Drilling de props excessif : Interdit à 5 niveaux ou plus de profondeur

    • Utiliser Context ou Composition
  2. Pas de Logique Métier : Interdire les appels API et les calculs complexes dans les composants UI

    • Séparer dans des hooks personnalisés
  3. 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

  1. Composition plutôt que Props : Utiliser les enfants plutôt que de nombreuses props
  2. Contrôlé vs Non contrôlé : Choisir en fonction de la situation
  3. Props par défaut : Fournir des valeurs par défaut raisonnables
  4. Storybook : Documentation et développement des composants

Références

Métadonnées

Version

  • Version actuelle : 1.0.0
  • Dernière mise à jour : 2025-01-01
  • Plateformes compatibles : Claude, ChatGPT, Gemini

Compétences connexes

Tags

#UI-components #React #design-patterns #composition #TypeScript #frontend

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Skills associés