@the-bearded-bear/claude-craft 3.0.0

package/Dev/i18n/fr/React/checklists/new-feature.md

@@ -0,0 +1,314 @@
+# Checklist : Nouvelle Fonctionnalité
+
+## Phase 1 : Analyse et Planification
+
+### Compréhension du Besoin
+
+- [ ] Clarifier l'objectif de la fonctionnalité
+- [ ] Identifier les utilisateurs cibles
+- [ ] Définir les critères d'acceptation
+- [ ] Lister les contraintes techniques et métier
+- [ ] Identifier les dépendances avec d'autres features
+
+### Analyse de l'Existant
+
+- [ ] Rechercher du code similaire dans le projet
+- [ ] Identifier les composants réutilisables
+- [ ] Vérifier les hooks existants
+- [ ] Analyser les patterns architecturaux utilisés
+- [ ] Comprendre la structure de state management
+
+### Documentation de l'Analyse
+
+- [ ] Créer un document d'analyse technique
+- [ ] Documenter les décisions architecturales
+- [ ] Lister les alternatives considérées
+- [ ] Justifier les choix techniques
+- [ ] Estimer la complexité et le temps
+
+## Phase 2 : Design Technique
+
+### Architecture
+
+- [ ] Définir la structure des dossiers
+- [ ] Identifier les composants à créer
+- [ ] Définir les hooks custom nécessaires
+- [ ] Planifier les services API
+- [ ] Concevoir la gestion d'état
+
+### Types TypeScript
+
+- [ ] Définir les interfaces principales
+- [ ] Créer les types métier
+- [ ] Définir les props des composants
+- [ ] Typer les retours de hooks
+- [ ] Créer les schémas de validation (Zod)
+
+### Exemple de Structure
+
+```
+features/new-feature/
+├── components/
+│   ├── FeatureList.tsx
+│   ├── FeatureDetail.tsx
+│   └── FeatureForm.tsx
+├── hooks/
+│   ├── useFeatureData.ts
+│   └── useFeatureMutations.ts
+├── services/
+│   └── feature.service.ts
+├── types/
+│   └── feature.types.ts
+├── utils/
+│   └── featureHelpers.ts
+└── index.ts
+```
+
+## Phase 3 : Implémentation
+
+### Types et Schémas
+
+- [ ] Créer les fichiers de types
+- [ ] Définir les schémas de validation Zod
+- [ ] Exporter les types
+- [ ] Documenter les types complexes
+
+### Services API
+
+- [ ] Créer le service API
+- [ ] Implémenter les méthodes CRUD
+- [ ] Gérer les erreurs proprement
+- [ ] Typer les requêtes et réponses
+- [ ] Ajouter les tests du service
+
+### Hooks Custom
+
+- [ ] Créer les hooks de data fetching (React Query)
+- [ ] Créer les hooks de mutations
+- [ ] Créer les hooks de logique métier
+- [ ] Documenter les hooks avec JSDoc
+- [ ] Ajouter les tests des hooks
+
+### Composants
+
+#### Composants de Base
+
+- [ ] Créer les composants Atoms si nécessaire
+- [ ] Créer les composants Molecules si nécessaire
+- [ ] Documenter avec JSDoc
+- [ ] Ajouter les Stories Storybook
+- [ ] Tester les composants
+
+#### Composants Feature
+
+- [ ] Créer les composants spécifiques
+- [ ] Séparer Container/Presenter si complexe
+- [ ] Implémenter la gestion d'état
+- [ ] Gérer les états de chargement/erreur
+- [ ] Optimiser les performances (memo, useMemo, useCallback)
+
+### Intégration
+
+- [ ] Intégrer dans le routing
+- [ ] Ajouter aux menus/navigation si nécessaire
+- [ ] Configurer les permissions si nécessaire
+- [ ] Intégrer avec le state management global
+- [ ] Tester l'intégration
+
+## Phase 4 : Tests
+
+### Tests Unitaires
+
+- [ ] Tests des composants (React Testing Library)
+- [ ] Tests des hooks (renderHook)
+- [ ] Tests des services
+- [ ] Tests des utilitaires
+- [ ] Coverage > 80%
+
+### Tests d'Intégration
+
+- [ ] Tests du flux complet de la feature
+- [ ] Tests des interactions entre composants
+- [ ] Tests avec MSW (mock API)
+- [ ] Tests des cas d'erreur
+
+### Tests E2E
+
+- [ ] Tests des parcours utilisateur critiques
+- [ ] Tests sur différents navigateurs si nécessaire
+- [ ] Tests responsive si applicable
+
+## Phase 5 : Qualité et Performance
+
+### Code Quality
+
+- [ ] Linting passé sans erreur
+- [ ] Formatting appliqué
+- [ ] Type-check passé
+- [ ] Pas de code dupliqué
+- [ ] Respect des principes SOLID
+- [ ] Respect de KISS/DRY/YAGNI
+
+### Performance
+
+- [ ] Optimisations de rendering (memo)
+- [ ] Code splitting si nécessaire
+- [ ] Images optimisées
+- [ ] Lazy loading implémenté
+- [ ] Bundle size vérifié
+
+### Sécurité
+
+- [ ] Inputs validés (Zod)
+- [ ] HTML sanitized si nécessaire
+- [ ] XSS prevention
+- [ ] CSRF protection
+- [ ] Pas de secrets exposés
+
+### Accessibilité
+
+- [ ] Sémantique HTML correcte
+- [ ] Labels et ARIA si nécessaire
+- [ ] Navigation au clavier
+- [ ] Contraste suffisant
+- [ ] Screen reader friendly
+
+## Phase 6 : Documentation
+
+### Code
+
+- [ ] JSDoc sur fonctions publiques
+- [ ] Commentaires pour logique complexe
+- [ ] Props documentées
+- [ ] Hooks documentés
+
+### Storybook
+
+- [ ] Stories pour composants réutilisables
+- [ ] Documentation des variants
+- [ ] Exemples d'usage
+
+### Projet
+
+- [ ] README mis à jour si nécessaire
+- [ ] Documentation technique créée
+- [ ] API reference mise à jour
+- [ ] CHANGELOG mis à jour
+
+## Phase 7 : Review et Merge
+
+### Pre-Review
+
+- [ ] Self-review du code
+- [ ] Vérification de la checklist pre-commit
+- [ ] Build réussit
+- [ ] Tests passent tous
+- [ ] Branch à jour avec develop
+
+### Pull Request
+
+- [ ] PR créée avec template rempli
+- [ ] Description claire et complète
+- [ ] Screenshots/GIFs si UI
+- [ ] Linked aux issues/tickets
+- [ ] Labels appropriés
+
+### Code Review
+
+- [ ] Review par au moins 1 personne
+- [ ] Commentaires adressés
+- [ ] Approbation obtenue
+- [ ] CI/CD passé
+
+### Merge
+
+- [ ] Conflits résolus si nécessaire
+- [ ] Squash commits si nécessaire
+- [ ] Message de merge clair
+- [ ] Merge dans develop
+
+## Phase 8 : Déploiement et Monitoring
+
+### Déploiement Staging
+
+- [ ] Feature déployée en staging
+- [ ] Tests manuels en staging
+- [ ] Tests de non-régression
+- [ ] Validation par Product Owner si nécessaire
+
+### Monitoring
+
+- [ ] Logs vérifiés
+- [ ] Pas d'erreurs en production
+- [ ] Performance acceptable
+- [ ] Analytics configurés si nécessaire
+
+### Communication
+
+- [ ] Équipe informée du déploiement
+- [ ] Documentation partagée
+- [ ] Demo si feature majeure
+- [ ] Release notes mises à jour
+
+## Checklist Rapide
+
+Pour référence rapide, les étapes essentielles :
+
+### Analyse
+
+- [ ] Analyser l'existant
+- [ ] Concevoir la solution
+- [ ] Documenter les décisions
+
+### Dev
+
+- [ ] Types TypeScript
+- [ ] Services API
+- [ ] Hooks custom
+- [ ] Composants
+- [ ] Tests > 80%
+
+### Quality
+
+- [ ] Lint + Format + Type-check
+- [ ] Performance optimisée
+- [ ] Sécurité vérifiée
+- [ ] Documentation complète
+
+### Merge
+
+- [ ] PR créée et reviewée
+- [ ] Tests passent
+- [ ] Build réussit
+- [ ] Merge et deploy
+
+## Questions à se Poser
+
+1. **Ai-je réutilisé au maximum le code existant ?**
+2. **La solution est-elle la plus simple possible (KISS) ?**
+3. **Ai-je évité la duplication (DRY) ?**
+4. **N'ai-je implémenté que ce qui est nécessaire (YAGNI) ?**
+5. **Les tests couvrent-ils tous les cas ?**
+6. **La feature est-elle performante ?**
+7. **La feature est-elle sécurisée ?**
+8. **La documentation est-elle complète ?**
+9. **Un nouveau développeur pourrait-il comprendre et maintenir ce code ?**
+
+## Estimation de Temps
+
+Pour estimer le temps, compter :
+
+- **Analyse** : 10-15% du temps total
+- **Design** : 10-15%
+- **Développement** : 40-50%
+- **Tests** : 15-20%
+- **Documentation** : 5-10%
+- **Review et ajustements** : 10-15%
+
+Exemple : Feature de 10h
+- Analyse : 1-1.5h
+- Design : 1-1.5h
+- Dev : 4-5h
+- Tests : 1.5-2h
+- Docs : 0.5-1h
+- Review : 1-1.5h

package/Dev/i18n/fr/React/checklists/pre-commit.md

@@ -0,0 +1,196 @@
+# Checklist Pre-Commit
+
+## Code Quality
+
+### Linting et Formatting
+
+- [ ] Code formaté avec Prettier (`pnpm run format`)
+- [ ] Aucune erreur ESLint (`pnpm run lint`)
+- [ ] Aucun warning ESLint non justifié
+- [ ] TypeScript compile sans erreur (`pnpm run type-check`)
+- [ ] Aucun `console.log` oublié (sauf `console.error` et `console.warn`)
+- [ ] Aucun code commenté non nécessaire
+- [ ] Aucun TODO sans ticket associé
+
+### Types TypeScript
+
+- [ ] Tous les types sont explicites (pas de `any`)
+- [ ] Les interfaces sont bien documentées
+- [ ] Les types sont exportés si réutilisables
+- [ ] Pas de `@ts-ignore` ou `@ts-nocheck` injustifiés
+- [ ] Utilisation de `type` vs `interface` cohérente
+
+### Imports
+
+- [ ] Imports organisés (React, externes, internes, types, styles)
+- [ ] Pas d'imports inutilisés
+- [ ] Utilisation des alias de chemin (`@/` au lieu de `../../../`)
+- [ ] Imports nommés plutôt que default (sauf pages/routes)
+
+## Tests
+
+### Coverage
+
+- [ ] Tests unitaires pour les nouveaux composants
+- [ ] Tests unitaires pour les nouveaux hooks
+- [ ] Tests d'intégration pour les nouvelles features
+- [ ] Tous les tests passent (`pnpm run test`)
+- [ ] Coverage maintenu > 80% (`pnpm run test:coverage`)
+
+### Qualité des Tests
+
+- [ ] Tests suivent le pattern AAA (Arrange, Act, Assert)
+- [ ] Tests testent le comportement, pas l'implémentation
+- [ ] Pas de tests fragiles (dépendant du timing)
+- [ ] Mocks utilisés seulement quand nécessaire
+- [ ] Tests e2e pour les parcours critiques modifiés
+
+## Documentation
+
+### Code
+
+- [ ] JSDoc/TSDoc pour les fonctions publiques
+- [ ] Commentaires pour la logique complexe (le "pourquoi")
+- [ ] Props des composants documentées
+- [ ] Hooks documentés avec exemples
+- [ ] README mis à jour si changement d'architecture
+
+### Storybook
+
+- [ ] Stories créées pour les nouveaux composants réutilisables
+- [ ] Stories couvrent les différents états
+- [ ] Props documentées dans Storybook
+
+## Architecture et Design
+
+### Composants
+
+- [ ] Composants suivent Single Responsibility Principle
+- [ ] Pas de composants > 200 lignes (sinon découper)
+- [ ] Container/Presenter séparés si logique complexe
+- [ ] Props typées avec TypeScript
+- [ ] Pas de props drilling excessif (> 2 niveaux)
+
+### Hooks
+
+- [ ] Hooks custom pour la logique réutilisable
+- [ ] Hooks respectent les rules of hooks
+- [ ] Pas de logique métier dans les composants
+- [ ] Dépendances des hooks correctes (exhaustive-deps)
+
+### Performance
+
+- [ ] Utilisation de `memo` pour composants purs lourds
+- [ ] Utilisation de `useMemo` pour calculs coûteux
+- [ ] Utilisation de `useCallback` pour callbacks passés aux enfants
+- [ ] Lazy loading pour routes et composants lourds
+- [ ] Images optimisées et lazy loadées
+
+## Sécurité
+
+### Validation
+
+- [ ] Tous les inputs utilisateur validés (Zod)
+- [ ] Sanitization du HTML utilisateur (DOMPurify)
+- [ ] URLs externes nettoyées
+- [ ] Pas de secrets hardcodés
+- [ ] Variables d'environnement utilisées pour secrets
+
+### XSS/CSRF
+
+- [ ] Pas d'usage de `dangerouslySetInnerHTML` sans sanitization
+- [ ] `rel="noopener noreferrer"` sur tous les liens externes
+- [ ] CSRF tokens inclus dans les mutations
+- [ ] Validation côté serveur en place (vérifier avec backend)
+
+## Git
+
+### Commits
+
+- [ ] Message de commit suit Conventional Commits
+- [ ] Format : `type(scope): subject`
+- [ ] Types valides : feat, fix, docs, style, refactor, test, chore
+- [ ] Sujet en impératif ("add" pas "added")
+- [ ] Sujet < 72 caractères
+- [ ] Body explique le "pourquoi" si nécessaire
+
+### Branches
+
+- [ ] Branch nommée correctement (`feature/`, `fix/`, etc.)
+- [ ] Branch à jour avec `develop`
+- [ ] Conflits résolus proprement
+- [ ] Pas de fichiers non intentionnels committé
+
+## Revue Personnelle
+
+### Lisibilité
+
+- [ ] Code facile à comprendre
+- [ ] Nommage explicite (variables, fonctions, composants)
+- [ ] Pas de "magic numbers" (utiliser des constantes)
+- [ ] Structure logique et cohérente
+
+### Maintenabilité
+
+- [ ] Pas de duplication de code (DRY)
+- [ ] Code modulaire et réutilisable
+- [ ] Dépendances minimales
+- [ ] Pas de sur-ingénierie (YAGNI)
+
+### Best Practices
+
+- [ ] Suit les patterns du projet
+- [ ] Respect des conventions de nommage
+- [ ] Pas de code mort
+- [ ] Erreurs gérées proprement
+
+## Build
+
+### Production
+
+- [ ] Build réussit (`pnpm run build`)
+- [ ] Pas de warnings de build
+- [ ] Bundle size raisonnable
+- [ ] Preview fonctionne (`pnpm run preview`)
+
+## Checklist Rapide (Minimum)
+
+Pour les petits changements, au minimum :
+
+- [ ] `pnpm run lint`
+- [ ] `pnpm run type-check`
+- [ ] `pnpm run test`
+- [ ] Commit message valide
+- [ ] Build réussit
+
+## Auto-Review Questions
+
+Pose-toi ces questions :
+
+1. **Clarté** : Un nouveau développeur pourrait-il comprendre ce code ?
+2. **Tests** : Ai-je testé tous les cas (nominal, erreur, edge cases) ?
+3. **Performance** : Y a-t-il des optimisations évidentes manquées ?
+4. **Sécurité** : Ai-je validé toutes les données utilisateur ?
+5. **Maintenance** : Ce code sera-t-il facile à modifier dans 6 mois ?
+
+## Avant de Push
+
+```bash
+# Script complet de vérification
+pnpm run lint:fix        # Fix linting
+pnpm run format          # Format code
+pnpm run type-check      # Verify types
+pnpm run test            # Run tests
+pnpm run build           # Verify build
+```
+
+## Automatisation
+
+Cette checklist est en partie automatisée par :
+
+- **Husky** : Git hooks
+- **lint-staged** : Lint des fichiers staged
+- **Commitlint** : Validation des messages de commit
+- **CI/CD** : Vérifications automatiques sur GitHub
+
+Mais certains points nécessitent une vérification manuelle !