Communitygithub.com

ComeOnOliver/skillshub

Tous les types TypeScript sont définis dans `frontend/types/index.ts`. Les types correspondent à la structure des réponses API backend et assurent la sécurité de typage dans toute l'application frontend.

Qu'est-ce que skillshub ?

Cette compétence définit un ensemble de règles et de modèles pour la création de définitions de types TypeScript dans le frontend, en suivant les conventions existantes du fichier `frontend/types/index.ts`. Elle garantit que tous les types correspondent précisément à la structure des réponses API backend, offrant ainsi une sécurité de typage optimale à travers l'application. Elle est utile pour les développeurs travaillant avec des architectures client-serveur, en particulier ceux qui utilisent React ou d'autres frameworks frontend modernes. La compétence couvre des modèles pour les types d'utilisateurs, de tâches, de réponses API, d'authentification, d'erreurs et d'interface utilisateur, avec des conventions de nommage claires. Elle explique également comment gérer la conversion entre les noms de champs snake_case (backend) et camelCase (formulaires frontend), ainsi que les règles pour les champs obligatoires et facultatifs. Des exemples complets montrent comment ajouter de nouveaux types, depuis la définition de l'entité jusqu'à l'utilisation dans un client API.

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

Demander à votre IA préférée

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

Documentation

Compétence de Types TypeScript Frontend

Objectif : Guide pour la création de définitions de types TypeScript en suivant les modèles existants de frontend/types/index.ts.

Vue d'ensemble

Tous les types TypeScript sont définis dans frontend/types/index.ts. Les types correspondent à la structure des réponses API backend et assurent la sécurité de typage dans toute l'application frontend.

Modèles de types de frontend/types/index.ts

1. Types utilisateur

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;
}

Modèle :

  • Utiliser interface pour les types objet
  • Marquer les champs facultatifs avec ?
  • Utiliser extends pour l'héritage de types
  • Utiliser camelCase pour les types frontend (même si le backend utilise snake_case)

2. Types de tâches

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;
}

Modèle :

  • Utiliser type pour les types union (littéraux de chaîne)
  • Utiliser interface pour les types objet
  • Faire correspondre les noms de champs du backend (snake_case pour les champs API comme user_id, due_date, created_at)
  • Créer des types séparés pour les données de formulaire (tous facultatifs sauf les champs obligatoires)
  • Créer des types séparés pour les paramètres de requête (tous facultatifs)

3. Types de réponse 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;
  };
}

Modèle :

  • Utiliser des types génériques <T> pour les structures réutilisables
  • Fournir un paramètre de type par défaut (<T = unknown>)
  • Inclure un indicateur booléen success
  • Inclure les champs facultatifs data, message et error
  • Créer un type séparé pour les réponses paginées avec l'objet meta

4. Types d'authentification

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

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

Modèle :

  • Inclure le booléen success
  • Inclure la chaîne token
  • Inclure l'objet user (type User)
  • Inclure le timestamp expiresAt pour la session

5. Types d'erreurs

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

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

Modèle :

  • Utiliser interface pour les objets d'erreur
  • Marquer les champs facultatifs avec ?
  • Utiliser la signature d'index [key: string] pour les types d'objets dynamiques (FormErrors)

6. Types d'interface utilisateur

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;
}

Modèle :

  • Utiliser type pour les types union (littéraux de chaîne)
  • Utiliser interface pour les types objet
  • Inclure id pour l'identification unique
  • Marquer les champs facultatifs avec ?

7. Types d'exportation/importation

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

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

Modèle :

  • Utiliser type pour les types union (littéraux de chaîne)
  • Utiliser interface pour les objets de résultat
  • Inclure des compteurs pour le suivi des succès/erreurs
  • Inclure un tableau de détails d'erreurs facultatif

Conventions de nommage des types

Interfaces

  • PascalCase : User, Task, ApiResponse
  • Noms descriptifs : TaskFormData, UserSignupData

Types (types union)

  • PascalCase : TaskStatus, TaskPriority, LoadingState
  • Noms descriptifs : ToastType, ExportFormat

Types de propriétés (Props)

  • NomDuComposant + Props : TaskItemProps, ProtectedRouteProps
  • Exemple : interface TaskItemProps { task: Task; }

Types de données de formulaire

  • NomEntité + FormData : TaskFormData, UserSignupData
  • Exemple : interface TaskFormData { title: string; description?: string; }

Types de paramètres de requête

  • NomEntité + QueryParams : TaskQueryParams
  • Exemple : interface TaskQueryParams { status?: "all" | "pending" | "completed"; }

Correspondance avec le schéma backend

Mappage des noms de champs

Backend (snake_case) → Frontend (camelCase pour les données de formulaire, snake_case pour les réponses API)

// Réponse API backend (correspond exactement au backend)
export interface Task {
  id: number;
  user_id: string;        // snake_case du backend
  title: string;
  due_date?: string;     // snake_case du backend
  created_at: string;    // snake_case du backend
  updated_at: string;    // snake_case du backend
}

// Données de formulaire frontend (camelCase pour une utilisation plus facile)
export interface TaskFormData {
  title: string;
  dueDate?: string;      // camelCase pour le frontend
  tags?: string[];
}

Modèle :

  • Les types de réponse API correspondent exactement au backend (snake_case)
  • Les types de données de formulaire utilisent camelCase pour une utilisation plus facile en frontend
  • Convertir entre les formats lors de l'envoi/réception depuis l'API

Champs obligatoires vs facultatifs

// Réponse API backend (tous les champs du backend)
export interface Task {
  id: number;              // Obligatoire (provenant du backend)
  user_id: string;         // Obligatoire (provenant du backend)
  title: string;           // Obligatoire (provenant du backend)
  description?: string;    // Facultatif (provenant du backend)
  completed: boolean;      // Obligatoire (provenant du backend)
  priority: TaskPriority;  // Obligatoire (provenant du backend)
  due_date?: string;       // Facultatif (provenant du backend)
  tags: string[];          // Obligatoire (provenant du backend, peut être un tableau vide)
  created_at: string;      // Obligatoire (provenant du backend)
  updated_at: string;      // Obligatoire (provenant du backend)
}

// Données de formulaire frontend (uniquement les champs que l'utilisateur peut modifier)
export interface TaskFormData {
  title: string;           // Obligatoire (l'utilisateur doit fournir)
  description?: string;    // Facultatif
  priority?: TaskPriority;  // Facultatif (a une valeur par défaut)
  due_date?: string;       // Facultatif
  tags?: string[];         // Facultatif (peut être un tableau vide)
}

Modèle :

  • Les types de réponse API incluent tous les champs du backend
  • Les types de données de formulaire n'incluent que les champs que l'utilisateur peut modifier
  • Marquer les champs facultatifs avec ?
  • Les champs obligatoires n'ont pas de ?

Modèles de structure de types

1. Utiliser interface pour les objets

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

Quand utiliser : Types objet avec propriétés

2. Utiliser type pour les unions, intersections ou alias

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

Quand utiliser : Types union, intersections ou alias de types

3. Utiliser des types génériques pour les structures réutilisables

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

Quand utiliser : Structures réutilisables fonctionnant avec différents types

4. Marquer les propriétés facultatives avec ?

export interface Task {
  title: string;        // Obligatoire
  description?: string; // Facultatif
}

Quand utiliser : Champs qui peuvent ne pas exister

Exemple complet : Ajout de nouveaux types

Étape 1 : Définir le type d'entité (correspond au backend)

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

Étape 2 : Définir le type de données de formulaire (pour la saisie utilisateur)

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

Étape 3 : Définir le type de paramètres de requête (pour les requêtes API)

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

Étape 4 : Utiliser dans le client API

async getCategories(
  userId: string,
  queryParams?: CategoryQueryParams
): Promise<ApiResponse<PaginatedResponse<Category>>> {
  // Implémentation
}

Exigences de la Constitution

  • FR-030 : Interfaces TypeScript typées pour tous les appels API ✅
  • FR-037 : Mode strict TypeScript ✅

Références

  • Spécification : specs/002-frontend-todo-app/spec.md - Définitions d'entités
  • Plan : specs/002-frontend-todo-app/plan.md - Contrats API avec types
  • Fichier de types : frontend/types/index.ts - Définitions de types complètes

Résumé des modèles courants

  1. ✅ Utiliser interface pour les types objet
  2. ✅ Utiliser type pour les types union (littéraux de chaîne)
  3. ✅ Utiliser des types génériques <T> pour les structures réutilisables
  4. ✅ Marquer les champs facultatifs avec ?
  5. ✅ Faire correspondre les noms de champs du backend (snake_case pour les réponses API)
  6. ✅ Utiliser camelCase pour les types de données de formulaire
  7. ✅ Créer des types séparés pour les données de formulaire et les paramètres de requête
  8. ✅ Utiliser des noms descriptifs (EntityFormData, EntityQueryParams)
  9. ✅ Inclure tous les champs obligatoires du backend
  10. ✅ Fournir des paramètres de type par défaut pour les génériques (<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 associés