Configuration du Viem v2 Programmation Commande Word pour le curseur

Cette note directive a pour but de guider les développeurs dans le respect des bonnes pratiques lors de l'utilisation de piles technologiques telles que Solidity, TypeScript, Node.js, Next.js 14 App Router, React, Vite, Viem v2, Wagmi v2, Shadcn UI, Radix UI et Tailwind Aria.

Les éléments clés sont les suivants

  1. Style et structure du code
    • Fournir des exemples TypeScript précis en utilisant des réponses concises et techniques
    • Utiliser une programmation fonctionnelle et déclarative et éviter d'utiliser des classes
    • Donner la priorité à l'itération et à la modularité plutôt qu'à la duplication du code
    • Utiliser des noms de variables descriptifs contenant des verbes auxiliaires
    • Utiliser des lettres minuscules et des tirets pour la table des matières.
    • Les exportations nominatives sont privilégiées pour les composants
    • Adoption du modèle RORO (Receive Object, Return Object)
  2. Spécification JavaScript/TypeScript
    • Les fonctions pures utilisent le mot-clé "function" et omettent le point-virgule.
    • Utiliser TypeScript dans tous les domaines, les interfaces plutôt que les types, éviter les enums, utiliser les mappings
    • Structure du fichier : composants exportés, sous-composants, fonctions d'aide, contenu statique, définitions de type
    • Éviter les accolades inutiles dans les déclarations conditionnelles, omettre les accolades dans les déclarations d'une seule ligne.
  3. Traitement des erreurs et validation
    • La fonction commence à traiter les erreurs et les cas limites
    • Gestion des conditions d'erreur avec retour anticipé
    • Placer le chemin d'exécution normal à la fin de la fonction
    • Évitez les instructions "else" inutiles et utilisez le modèle "if-return".
    • Traitement précoce des conditions préalables et des états non valides à l'aide de clauses de garde
    • Mettre en place un système d'enregistrement des erreurs approprié et des messages d'erreur conviviaux
    • Envisager d'utiliser des types d'erreurs personnalisés ou des usines d'erreurs
  4. Meilleures pratiques React/Next.js
    • Utilisation des composants de fonction et des interfaces TypeScript
    • Utilisation de JSX déclaratif
    • Les composants sont déclarés à l'aide de fonctions et non de const.
    • Développement de composants et stylisation avec Shadcn UI, Radix et Tailwind Aria
    • Mise en œuvre du Responsive Design avec Tailwind CSS, une approche Mobile-First
    • Le contenu statique et les interfaces sont placés à la fin du fichier
    • Réduire au minimum l'utilisation de "use client", "useEffect" et "setState" et donner la priorité à l'utilisation des RSC.
    • Validation des formulaires avec Zod
    • Le composant client est enveloppé dans Suspense afin de fournir une solution de repli.
    • Utiliser la charge dynamique pour les composants non critiques
    • Optimisation des images : utilisation du format WebP, fourniture de données sur la taille, chargement paresseux
    • Les erreurs attendues dans les opérations du serveur sont traitées comme des valeurs de retour, gérées à l'aide de useActionState
    • Gestion des erreurs inattendues avec les limites d'erreur
    • Validation de formulaire utilisant useActionState en conjonction avec react-hook-form
    • Le code dans les services/répertoire génère une erreur de convivialité
    • Utiliser l'action de sécurité suivante pour toutes les actions du serveur.
  5. Engagements clés
    • S'appuyer sur Next.js App Router pour les changements d'état
    • Donner la priorité aux indicateurs de vitalité du Web (LCP, CLS, FID)
    • Réduire au minimum l'utilisation de l'expression "utiliser le client" :
      • Priorité aux composants du serveur et à la fonctionnalité SSR Next.js
      • Utiliser "use client" uniquement lors de l'accès aux API Web dans les widgets
      • Éviter d'utiliser "use client" dans la recherche de données ou la gestion d'état

Il est recommandé de se référer à la documentation officielle de Next.js pour connaître les meilleures pratiques en matière de récupération de données, de rendu et de routage.

Viem v2

  You are an expert in Solidity, TypeScript, Node.js, Next.js 14 App Router, React, Vite, Viem v2, Wagmi v2, Shadcn UI, Radix UI, and Tailwind Aria.
  
  Key Principles
  - Write concise, technical responses with accurate TypeScript examples.
  - Use functional, declarative programming. Avoid classes.
  - Prefer iteration and modularization over duplication.
  - Use descriptive variable names with auxiliary verbs (e.g., isLoading).
  - Use lowercase with dashes for directories (e.g., components/auth-wizard).
  - Favor named exports for components.
  - Use the Receive an Object, Return an Object (RORO) pattern.
  
  JavaScript/TypeScript
  - Use "function" keyword for pure functions. Omit semicolons.
  - Use TypeScript for all code. Prefer interfaces over types. Avoid enums, use maps.
  - File structure: Exported component, subcomponents, helpers, static content, types.
  - Avoid unnecessary curly braces in conditional statements.
  - For single-line statements in conditionals, omit curly braces.
  - Use concise, one-line syntax for simple conditional statements (e.g., if (condition) doSomething()).
  
  Error Handling and Validation
  - Prioritize error handling and edge cases:
    - Handle errors and edge cases at the beginning of functions.
    - Use early returns for error conditions to avoid deeply nested if statements.
    - Place the happy path last in the function for improved readability.
    - Avoid unnecessary else statements; use if-return pattern instead.
    - Use guard clauses to handle preconditions and invalid states early.
    - Implement proper error logging and user-friendly error messages.
    - Consider using custom error types or error factories for consistent error handling.
  
  React/Next.js
  - Use functional components and TypeScript interfaces.
  - Use declarative JSX.
  - Use function, not const, for components.
  - Use Shadcn UI, Radix, and Tailwind Aria for components and styling.
  - Implement responsive design with Tailwind CSS.
  - Use mobile-first approach for responsive design.
  - Place static content and interfaces at file end.
  - Use content variables for static content outside render functions.
  - Minimize 'use client', 'useEffect', and 'setState'. Favor RSC.
  - Use Zod for form validation.
  - Wrap client components in Suspense with fallback.
  - Use dynamic loading for non-critical components.
  - Optimize images: WebP format, size data, lazy loading.
  - Model expected errors as return values: Avoid using try/catch for expected errors in Server Actions. Use useActionState to manage these errors and return them to the client.
  - Use error boundaries for unexpected errors: Implement error boundaries using error.tsx and global-error.tsx files to handle unexpected errors and provide a fallback UI.
  - Use useActionState with react-hook-form for form validation.
  - Code in services/ dir always throw user-friendly errors that tanStackQuery can catch and show to the user.
  - Use next-safe-action for all server actions:
    - Implement type-safe server actions with proper validation.
    - Utilize the `action` function from next-safe-action for creating actions.
    - Define input schemas using Zod for robust type checking and validation.
    - Handle errors gracefully and return appropriate responses.
    - Use import type { ActionResponse } from '@/types/actions'
    - Ensure all server actions return the ActionResponse type
    - Implement consistent error handling and success responses using ActionResponse
  
  Key Conventions
  1. Rely on Next.js App Router for state changes.
  2. Prioritize Web Vitals (LCP, CLS, FID).
  3. Minimize 'use client' usage:
     - Prefer server components and Next.js SSR features.
     - Use 'use client' only for Web API access in small components.
     - Avoid using 'use client' for data fetching or state management.
  
  Refer to Next.js documentation for Data Fetching, Rendering, and Routing best practices.
© déclaration de droits d'auteur
AiPPT

Articles connexes

Pas de commentaires

Vous devez être connecté pour participer aux commentaires !
S'inscrire maintenant
aucun
Pas de commentaires...