Communitygithub.com

Accessibilité (WCAG 2.2)

Concevoir, implémenter et auditer des produits numériques inclusifs conformes au WCAG 2.2 niveau AA. Utilisez-le lors de la construction ou de l'audit d'IHM devant respecter le WCAG 2.2 niveau AA, ou lors de la revue d'une modification pour la prise en charge du clavier, du contraste ou des lecteurs d'écran.

Qu'est-ce que Accessibilité (WCAG 2.2) ?

Cette compétence garantit que les interfaces numériques sont Perceptibles, Utilisables, Compréhensibles et Robuste (POUR) pour tous les utilisateurs, y compris ceux qui utilisent des lecteurs d'écran, des commandes par commutateur ou une navigation au clavier. Elle couvre l'implémentation technique des critères de succès WCAG 2.2 et fournit des conseils pour les plateformes Web, iOS et Android. L'utilisateur apprend à définir des attributs perceptibles (contraste, alternatives textuelles), à implémenter des contrôles opérables (taille cible minimale, indicateur de focus visible), à assurer une logique compréhensible (messages d'erreur, navigation cohérente) et à vérifier la compatibilité robuste (ARIA, régions live). Elle inclut des exemples concrets, des anti-patrons à éviter et une checklist de bonnes pratiques pour auditer et améliorer l'accessibilité.

Compatible avec~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/affaan-m/ECC/tree/main/skills/accessibility

Demander à votre IA préférée

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

Documentation

Que fait Accessibilité (WCAG 2.2) ?

Cette compétence garantit que les interfaces numériques sont Perceptibles, Utilisables, Compréhensibles et Robuste (POUR) pour tous les utilisateurs, y compris ceux qui utilisent des lecteurs d'écran, des commandes par commutateur ou une navigation au clavier. Elle se concentre sur l'implémentation technique des critères de succès WCAG 2.2.

Quand l'utiliser

  • Définir les spécifications des composants d'interface pour le Web, iOS ou Android.
  • Auditer le code existant pour détecter les barrières d'accessibilité ou les lacunes de conformité.
  • Implémenter les nouvelles normes WCAG 2.2 telles que la taille cible (minimum) et l'apparence du focus.
  • Faire correspondre les exigences de conception de haut niveau aux attributs techniques (rôles ARIA, traits, indices).

Concepts clés

  • Principes POUR : Le fondement du WCAG (Perceptible, Utilisable, Compréhensible, Robuste).
  • Correspondance sémantique : Utiliser des éléments natifs plutôt que des conteneurs génériques pour bénéficier d'une accessibilité intégrée.
  • Arbre d'accessibilité : La représentation de l'interface que les technologies d'assistance "lisent" réellement.
  • Gestion du focus : Contrôler l'ordre et la visibilité du curseur du clavier/lecteur d'écran.
  • Étiquetage et indices : Fournir du contexte via aria-label, accessibilityLabel et contentDescription.

Comment ça fonctionne

Étape 1 : Identifier le rôle du composant

Déterminez la fonctionnalité (par exemple, s'agit-il d'un bouton, d'un lien ou d'un onglet ?). Utilisez l'élément natif le plus sémantique disponible avant d'utiliser des rôles personnalisés.

Étape 2 : Définir les attributs perceptibles

  • Assurez-vous que le contraste du texte atteint 4.5:1 (normal) ou 3:1 (grand/IHM).
  • Ajoutez des alternatives textuelles pour le contenu non textuel (images, icônes).
  • Implémentez le réajustement réactif (jusqu'à 400 % de zoom sans perte de fonction).

Étape 3 : Implémenter des contrôles utilisables

  • Assurez une taille cible minimale de 24x24 pixels CSS (WCAG 2.2 SC 2.5.8).
  • Vérifiez que tous les éléments interactifs sont atteignables via le clavier et disposent d'un indicateur de focus visible (SC 2.4.11).
  • Proposez des alternatives à un seul pointeur pour les mouvements de glissement.

Étape 4 : Assurer une logique compréhensible

  • Utilisez des motifs de navigation cohérents.
  • Fournissez des messages d'erreur descriptifs et des suggestions de correction (SC 3.3.3).
  • Implémentez la "Saisie redondante" (SC 3.3.7) pour éviter de demander deux fois les mêmes données.

Étape 5 : Vérifier la compatibilité robuste

  • Utilisez des motifs corrects de Nom, Rôle, Valeur.
  • Implémentez aria-live ou des régions live pour les mises à jour dynamiques de statut.

Diagramme d'architecture d'accessibilité

flowchart TD
  UI["Composant IHM"] --> Platform{Plateforme?}
  Platform -->|Web| ARIA["WAI-ARIA + HTML5"]
  Platform -->|iOS| SwiftUI["Traits d'accessibilité + Étiquettes"]
  Platform -->|Android| Compose["Sémantique + ContentDesc"]

  ARIA --> AT["Technologie d'assistance (Lecteurs d'écran, Commutateurs)"]
  SwiftUI --> AT
  Compose --> AT

Correspondance multiplateforme

FonctionnalitéWeb (HTML/ARIA)iOS (SwiftUI)Android (Compose)
Étiquette principalearia-label / <label>.accessibilityLabel()contentDescription
Indice secondairearia-describedby.accessibilityHint()Modifier.semantics { stateDescription = ... }
Rôle d'actionrole="button".accessibilityAddTraits(.isButton)Modifier.semantics { role = Role.Button }
Mises à jour livearia-live="polite".accessibilityLiveRegion(.polite)Modifier.semantics { liveRegion = LiveRegionMode.Polite }

Exemples

Web : Recherche accessible

<form role="search">
  <label for="search-input" class="sr-only">Rechercher des produits</label>
  <input type="search" id="search-input" placeholder="Rechercher..." />
  <button type="submit" aria-label="Soumettre la recherche">
    <svg aria-hidden="true">...</svg>
  </button>
</form>

iOS : Bouton d'action accessible

Button(action: deleteItem) {
    Image(systemName: "trash")
}
.accessibilityLabel("Supprimer l'élément")
.accessibilityHint("Supprime définitivement cet élément de votre liste")
.accessibilityAddTraits(.isButton)

Android : Bouton à bascule accessible

Switch(
    checked = isEnabled,
    onCheckedChange = { onToggle() },
    modifier = Modifier.semantics {
        contentDescription = "Activer les notifications"
    }
)

Anti-patrons à éviter

  • Div-Boutons : Utiliser une <div> ou un <span> pour un événement de clic sans ajouter de rôle ni de prise en charge du clavier.
  • Signification uniquement par couleur : Indiquer une erreur ou un statut uniquement par un changement de couleur (par exemple, faire passer une bordure en rouge).
  • Focus modal non contenu : Des modaux qui ne piègent pas le focus, permettant aux utilisateurs du clavier de naviguer dans le contenu en arrière-plan pendant que le modal est ouvert. Le focus doit être contenu et accessible via la touche Échap ou un bouton de fermeture explicite (WCAG SC 2.1.2).
  • Texte alternatif redondant : Utiliser "Image de..." ou "Photo de..." dans le texte alternatif (les lecteurs d'écran annoncent déjà le rôle "Image").

Liste de vérification des bonnes pratiques

  • Les éléments interactifs respectent une taille cible de 24x24 px (Web) ou 44x44 pt (Natif).
  • Les indicateurs de focus sont clairement visibles et à contraste élevé.
  • Les modaux contiennent le focus lorsqu'ils sont ouverts, et le libèrent correctement à la fermeture (touche Échap ou bouton de fermeture).
  • Les listes déroulantes et les menus rétablissent le focus sur l'élément déclencheur à la fermeture.
  • Les formulaires fournissent des suggestions d'erreur textuelles.
  • Tous les boutons uniquement iconiques ont une étiquette textuelle descriptive.
  • Le contenu se réajuste correctement lorsque le texte est agrandi.

Références

Compétences connexes

  • frontend-patterns
  • design-system
  • liquid-glass-design
  • swiftui-patterns

Individual skills in this repo

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

affaan-m/content-engine

Create platform-native content systems for X, LinkedIn, TikTok, YouTube, newsletters, and repurposed multi-platform campaigns. Use when the user wants social posts, threads, scripts, content calendars, or one source asset adapted cleanly across platforms.

affaan-m/ECC

Multi-platform content distribution across X, LinkedIn, Threads, and Bluesky. Adapts content per platform using content-engine patterns. Never posts identical content cross-platform. Use when the user wants to distribute content across social platforms.

affaan-m/fal-ai-media

Unified media generation via fal.ai MCP — image, video, and audio. Covers text-to-image (Nano Banana), text/image-to-video (Seedance, Kling, Veo 3), text-to-speech (CSM-1B), and video-to-audio (ThinkSound). Use when the user wants to generate images, videos, or audio with AI.

affaan-m/manim-video

日本語翻訳:このファイルは manim-video 用の日本語翻訳が必要です

affaan-m/remotion-video-creation

Remotion のベストプラクティス - React で動画を作成する。3D、アニメーション、音声、字幕、チャート、トランジションなどをカバーするドメイン固有の29のルール。

affaan-m/video-editing

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.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

agent-self-evaluation

Use after completing any non-trivial task. The agent self-rates its output on 5 axes — accuracy, completeness, clarity, actionability, conciseness — with concrete evidence per criterion. Produces a structured 1-5 scorecard with specific improvement suggestions.

agent-sort

Build an evidence-backed ECC install plan for a specific repo by sorting skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using parallel repo-aware review passes. Use when ECC should be trimmed to what a project actually needs instead of loading the full bundle.

ai-first-engineering

Engineering operating model for teams where AI agents generate a large share of implementation output. Use when setting team process, review gates, or ownership rules for a codebase largely written by agents.

ai-regression-testing

Regression testing strategies for AI-assisted development. Sandbox-mode API testing without database dependencies, automated bug-check workflows, and patterns to catch AI blind spots where the same model writes and reviews code. Use when adding regression coverage to AI-assisted code, or when the same model both wrote and reviewed a change.

android-clean-architecture

Clean Architecture patterns for Android and Kotlin Multiplatform projects — module structure, dependency rules, UseCases, Repositories, and data layer patterns. Use when structuring modules, layers, or data flow in an Android or KMP project.

angular-developer

Generates Angular code and provides architectural guidance. Trigger when creating projects, components, or services, or for best practices on reactivity (signals, linkedSignal, resource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, or CLI tooling.

api-connector-builder

Build a new API connector or provider by matching the target repo

Skills associés