Communitygithub.com

Conocimiento de Tipos TypeScript del Frontend

Todos los tipos de TypeScript se definen en `frontend/types/index.ts`. Los tipos coinciden con la estructura de respuesta de la API del backend y proporcionan seguridad de tipos en toda la aplicación frontend.

¿Qué es Conocimiento de Tipos TypeScript del Frontend?

Este skill proporciona una guía completa y un conjunto de patrones para crear definiciones de tipos TypeScript en una aplicación frontend, siguiendo las convenciones establecidas en `frontend/types/index.ts`. Su propósito es garantizar que todos los tipos utilizados en el frontend coincidan con la estructura de respuesta de la API del backend, asegurando así la seguridad de tipos en toda la aplicación y evitando errores comunes de desarrollo. El skill detalla patrones para tipos de usuario, tareas, respuestas de API, autenticación, errores, interfaz de usuario y exportación/importación. Incluye convenciones de nomenclatura (PascalCase para interfaces y tipos de unión, sufijos como `FormData` y `QueryParams`), reglas para mapear nombres de campos entre el backend (snake_case) y el frontend (camelCase para formularios), y directrices sobre campos requeridos versus opcionales. También cubre el uso de tipos genéricos, tipos de unión, interfaces para objetos y propiedades opcionales. El skill está diseñado para ser utilizado en el desarrollo con TypeScript, y su contenido se basa en los requisitos de la constitución del proyecto (FR-030 y FR-037). Proporciona ejemplos prácticos y pasos para añadir nuevos tipos, como un tipo `Category`, y referencias a la especificación y el plan del proyecto.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/aiskillstore/marketplace/asmayaseen/frontend-types

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

¿Qué hace Conocimiento de Tipos TypeScript del Frontend?

Propósito: Guía para crear definiciones de tipos TypeScript siguiendo los patrones existentes de frontend/types/index.ts.

Resumen

Todos los tipos de TypeScript se definen en frontend/types/index.ts. Los tipos coinciden con la estructura de respuesta de la API del backend y proporcionan seguridad de tipos en toda la aplicación frontend.

Patrones de Tipos de frontend/types/index.ts

1. Tipos de Usuario

export interface User {
  id: string;
  email: string;
  name: string;
  createdAt?: string;
  updatedAt?: string;
}

export interface UserCredentials {
  email: string;
  password: string;
}

export interface UserSignupData extends UserCredentials {
  name: string;
}

Patrón:

  • Usar interface para tipos de objeto
  • Marcar campos opcionales con ?
  • Usar extends para herencia de tipos
  • Usar camelCase para tipos del frontend (incluso si el backend usa snake_case)

2. Tipos de Tarea

export type TaskStatus = "pending" | "completed";
export type TaskPriority = "low" | "medium" | "high";

export interface Task {
  id: number;
  user_id: string;
  title: string;
  description?: string;
  completed: boolean;
  priority: TaskPriority;
  due_date?: string;
  tags: string[];
  created_at: string;
  updated_at: string;
}

export interface TaskFormData {
  title: string;
  description?: string;
  priority?: TaskPriority;
  due_date?: string;
  tags?: string[];
}

export interface TaskQueryParams {
  status?: "all" | "pending" | "completed";
  sort?: "created" | "title" | "updated" | "priority" | "due_date";
  search?: string;
  page?: number;
  limit?: number;
}

Patrón:

  • Usar type para tipos unión (literales de cadena)
  • Usar interface para tipos de objeto
  • Coincidir con los nombres de campo del backend (snake_case para campos de API como user_id, due_date, created_at)
  • Crear tipos separados para datos de formulario (todos opcionales excepto los campos requeridos)
  • Crear tipos separados para parámetros de consulta (todos opcionales)

3. Tipos de Respuesta de API

export interface ApiResponse<T = unknown> {
  data?: T;
  success: boolean;
  message?: string;
  error?: {
    code: string;
    message: string;
    details?: unknown;
  };
}

export interface PaginatedResponse<T> {
  data: T[];
  meta: {
    total: number;
    page: number;
    limit: number;
    totalPages: number;
  };
}

Patrón:

  • Usar tipos genéricos <T> para estructuras reutilizables
  • Proporcionar un parámetro de tipo por defecto (<T = unknown>)
  • Incluir un indicador booleano success
  • Incluir campos opcionales data, message y error
  • Crear un tipo separado para respuestas paginadas con un objeto meta

4. Tipos de Autenticación

export interface AuthResponse {
  success: boolean;
  token: string;
  user: User;
}

export interface Session {
  user: User;
  token: string;
  expiresAt: number;
}

Patrón:

  • Incluir booleano success
  • Incluir cadena token
  • Incluir objeto user (tipo User)
  • Incluir expiresAt como marca de tiempo para la sesión

5. Tipos de Error

export interface AppError {
  message: string;
  code?: string;
  statusCode?: number;
  field?: string;
}

export interface FormErrors {
  [key: string]: string | undefined;
}

Patrón:

  • Usar interface para objetos de error
  • Marcar campos opcionales con ?
  • Usar firma de índice [key: string] para tipos dinámicos de objeto (FormErrors)

6. Tipos de IU

export type LoadingState = "idle" | "loading" | "success" | "error";

export type ToastType = "success" | "error" | "warning" | "info";

export interface ToastMessage {
  id: string;
  type: ToastType;
  message: string;
  duration?: number;
}

Patrón:

  • Usar type para tipos unión (literales de cadena)
  • Usar interface para tipos de objeto
  • Incluir id para identificación única
  • Marcar campos opcionales con ?

7. Tipos de Exportación/Importación

export type ExportFormat = "csv" | "json";

export interface ImportResult {
  imported: number;
  errors: number;
  errorDetails?: string[];
}

Patrón:

  • Usar type para tipos unión (literales de cadena)
  • Usar interface para objetos de resultado
  • Incluir contadores para seguimiento de éxito/error
  • Incluir arreglo opcional de detalles de error

Convenciones de Nomenclatura de Tipos

Interfaces

  • PascalCase: User, Task, ApiResponse
  • Nombres descriptivos: TaskFormData, UserSignupData

Tipos (Tipos Unión)

  • PascalCase: TaskStatus, TaskPriority, LoadingState
  • Nombres descriptivos: ToastType, ExportFormat

Tipos de Props

  • NombreDelComponente + Props: TaskItemProps, ProtectedRouteProps
  • Ejemplo: interface TaskItemProps { task: Task; }

Tipos de Datos de Formulario

  • NombreDeLaEntidad + FormData: TaskFormData, UserSignupData
  • Ejemplo: interface TaskFormData { title: string; description?: string; }

Tipos de Parámetros de Consulta

  • NombreDeLaEntidad + QueryParams: TaskQueryParams
  • Ejemplo: interface TaskQueryParams { status?: "all" | "pending" | "completed"; }

Coincidencia con el Esquema del Backend

Mapeo de Nombres de Campo

Backend (snake_case) → Frontend (camelCase para datos de formulario, snake_case para respuesta de API)

// Respuesta de API del backend (coincide exactamente con el backend)
export interface Task {
  id: number;
  user_id: string;        // snake_case del backend
  title: string;
  due_date?: string;     // snake_case del backend
  created_at: string;    // snake_case del backend
  updated_at: string;    // snake_case del backend
}

// Datos de formulario del frontend (camelCase para uso más fácil)
export interface TaskFormData {
  title: string;
  dueDate?: string;      // camelCase para el frontend
  tags?: string[];
}

Patrón:

  • Los tipos de respuesta de API coinciden exactamente con el backend (snake_case)
  • Los tipos de datos de formulario usan camelCase para un uso más fácil en el frontend
  • Convertir entre formatos al enviar/recibir desde la API

Campos Requeridos vs Opcionales

// Respuesta de API del backend (todos los campos del backend)
export interface Task {
  id: number;              // Requerido (del backend)
  user_id: string;         // Requerido (del backend)
  title: string;           // Requerido (del backend)
  description?: string;    // Opcional (del backend)
  completed: boolean;      // Requerido (del backend)
  priority: TaskPriority;  // Requerido (del backend)
  due_date?: string;       // Opcional (del backend)
  tags: string[];          // Requerido (del backend, puede ser arreglo vacío)
  created_at: string;      // Requerido (del backend)
  updated_at: string;      // Requerido (del backend)
}

// Datos de formulario del frontend (solo campos que el usuario puede editar)
export interface TaskFormData {
  title: string;           // Requerido (el usuario debe proporcionarlo)
  description?: string;    // Opcional
  priority?: TaskPriority;  // Opcional (tiene valor por defecto)
  due_date?: string;       // Opcional
  tags?: string[];         // Opcional (puede ser arreglo vacío)
}

Patrón:

  • Los tipos de respuesta de API incluyen todos los campos del backend
  • Los tipos de datos de formulario solo incluyen campos que el usuario puede editar
  • Marcar campos opcionales con ?
  • Los campos requeridos no tienen ?

Patrones de Estructura de Tipos

1. Usar interface para Objetos

export interface User {
  id: string;
  email: string;
}

Cuándo usar: Tipos de objeto con propiedades

2. Usar type para Uniones, Intersecciones o Alias

export type TaskStatus = "pending" | "completed";
export type TaskPriority = "low" | "medium" | "high";

Cuándo usar: Tipos unión, intersecciones o alias de tipos

3. Usar Tipos Genéricos para Estructuras Reutilizables

export interface ApiResponse<T = unknown> {
  data?: T;
  success: boolean;
}

Cuándo usar: Estructuras reutilizables que funcionan con diferentes tipos

4. Marcar Propiedades Opcionales con ?

export interface Task {
  title: string;        // Requerido
  description?: string; // Opcional
}

Cuándo usar: Campos que pueden no existir

Ejemplo Completo: Agregar Nuevos Tipos

Paso 1: Definir el Tipo de Entidad (coincide con el backend)

export interface Category {
  id: number;
  user_id: string;
  name: string;
  color?: string;
  created_at: string;
  updated_at: string;
}

Paso 2: Definir el Tipo de Datos de Formulario (para entrada del usuario)

export interface CategoryFormData {
  name: string;
  color?: string;
}

Paso 3: Definir el Tipo de Parámetros de Consulta (para consultas de API)

export interface CategoryQueryParams {
  search?: string;
  page?: number;
  limit?: number;
}

Paso 4: Usar en el Cliente de API

async getCategories(
  userId: string,
  queryParams?: CategoryQueryParams
): Promise<ApiResponse<PaginatedResponse<Category>>> {
  // Implementación
}

Requisitos de la Constitución

  • FR-030: Interfaces TypeScript con tipos para todas las llamadas a la API ✅
  • FR-037: Modo estricto de TypeScript ✅

Referencias

  • Especificación: specs/002-frontend-todo-app/spec.md - Definiciones de entidad
  • Plan: specs/002-frontend-todo-app/plan.md - Contratos de API con tipos
  • Archivo de Tipos: frontend/types/index.ts - Definiciones de tipos completas

Resumen de Patrones Comunes

  1. ✅ Usar interface para tipos de objeto
  2. ✅ Usar type para tipos unión (literales de cadena)
  3. ✅ Usar tipos genéricos <T> para estructuras reutilizables
  4. ✅ Marcar campos opcionales con ?
  5. ✅ Coincidir con los nombres de campo del backend (snake_case para respuestas de API)
  6. ✅ Usar camelCase para tipos de datos de formulario
  7. ✅ Crear tipos separados para datos de formulario y parámetros de consulta
  8. ✅ Usar nombres descriptivos (EntityFormData, EntityQueryParams)
  9. ✅ Incluir todos los campos requeridos del backend
  10. ✅ Proporcionar parámetros de tipo por defecto para genéricos (<T = unknown>)

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 relacionados