Configuración del comando Viem v2 Programming Prompt Word para el cursor

Comandos de utilidad de AIPublicado hace 11 meses Círculo de intercambio de inteligencia artificial

2.9K 00

Esta nota directiva pretende guiar a los desarrolladores para que sigan las mejores prácticas al utilizar pilas tecnológicas como Solidity, TypeScript, Node.js, Next.js 14 App Router, React, Vite, Viem v2, Wagmi v2, Shadcn UI, Radix UI y Tailwind Aria.

Entre los elementos clave figuran.

Estilo y estructura del código
- Proporcionar ejemplos precisos de TypeScript utilizando respuestas concisas y técnicas.
- Utilizar programación funcional y declarativa y evitar el uso de clases
- Priorizar el uso de la iteración y la modularidad sobre el código duplicado.
- Utilice nombres de variables descriptivos que contengan verbos auxiliares
- Utilice minúsculas con guiones para el índice
- Para los componentes se prefieren las exportaciones con nombre
- Adopción del modelo RORO (Receive Object, Return Object)
Especificación JavaScript/TypeScript
- Las funciones puras utilizan la palabra clave "function" y omiten el punto y coma.
- Utilizar TypeScript de forma generalizada, interfaces en lugar de tipos, evitar enums, utilizar mappings
- Estructura del fichero: componentes exportados, subcomponentes, funciones auxiliares, contenido estático, definiciones de tipos
- Evite las llaves innecesarias en las sentencias condicionales, omita las llaves en las sentencias de una sola línea.
Tratamiento de errores y validación
- La función empieza a tratar errores y casos extremos
- Tratamiento de condiciones de error con retorno anticipado
- Coloca la ruta de ejecución normal al final de la función
- Evite las sentencias else innecesarias y utilice el patrón if-return
- Tratamiento anticipado de precondiciones y estados no válidos mediante cláusulas de guarda
- Implementar un registro de errores adecuado y mensajes de error fáciles de usar.
- Considere la posibilidad de utilizar tipos de error personalizados o fábricas de errores
Mejores prácticas de React/Next.js
- Uso de componentes de función e interfaces TypeScript
- Uso de JSX declarativo
- Los componentes se declaran utilizando function, no const.
- Desarrollo de componentes y estilización con Shadcn UI, Radix y Tailwind Aria
- Implementación del diseño adaptativo con Tailwind CSS con un enfoque Mobile-First
- El contenido estático y las interfaces se colocan al final del fichero
- Minimizar el uso de "use client", "useEffect" y "setState" y priorizar el uso de los RSC.
- Validación de formularios con Zod
- El componente cliente está envuelto en Suspense para proporcionar una solución de emergencia.
- Utilice la carga dinámica para los componentes no críticos
- Optimización de imágenes: uso del formato WebP, suministro de datos de tamaño, lazy loading
- Los errores esperados en las operaciones del servidor se tratan como valores de retorno, gestionados mediante useActionState
- Tratamiento de errores inesperados con límites de error
- Validación de formularios usando useActionState junto con react-hook-form
- El código en services/ directory arroja errores fáciles de usar
- Utilice next-safe-action para todas las acciones del servidor.
Compromisos clave
- Depender de Next.js App Router para los cambios de estado
- Dar prioridad a las métricas de Web Vitals (LCP, CLS, FID)
- Minimizar el uso de "utilizar cliente":
  - Dar prioridad a los componentes del servidor y a la funcionalidad SSR de Next.js
  - Utilice "usar cliente" sólo cuando acceda a las API web en los widgets
  - Evitar el uso de "usar cliente" en la obtención de datos o la gestión de estados

Se recomienda consultar la documentación oficial de Next.js para conocer las mejores prácticas de obtención, representación y enrutamiento de datos.

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.