Communitygithub.com

ComeOnOliver/skillshub

Alle TypeScript-Typen sind in `frontend/types/index.ts` definiert. Die Typen entsprechen der Backend-API-Antwortstruktur und gewährleisten Typsicherheit in der gesamten Frontend-Anwendung.

Was ist skillshub?

Diese Skill bietet eine umfassende Anleitung zur Erstellung von TypeScript-Typdefinitionen, die den bestehenden Mustern in `frontend/types/index.ts` folgen. Sie ist für Entwickler gedacht, die an einer Frontend-Anwendung mit TypeScript arbeiten und konsistente, typsichere Schnittstellen zu einer Backend-API benötigen. Die Skill unterstützt alle gängigen Entwicklungsumgebungen wie Claude Code, Cursor und Codex und bietet klare Muster für Benutzer-, Aufgaben-, API-Antwort-, Authentifizierungs-, Fehler- und UI-Typen. Sie erklärt, wann `interface` für Objekttypen und `type` für Union-Typen (String-Literale) verwendet werden sollte, sowie die Konventionen für benutzerdefinierte Formulardaten und Abfrageparameter. Darüber hinaus geht die Skill auf die korrekte Abbildung von Backend-Feldnamen (snake_case) auf Frontend-Typen (camelCase für Formulare, snake_case für API-Antworten) ein und zeigt, wie Generika für wiederverwendbare Strukturen wie `ApiResponse<T>` eingesetzt werden. Abschließend wird ein vollständiges Beispiel für das Hinzufügen neuer Typen (z. B. einer Category) durchlaufen, das die Schritte von der Definition des Entitätstyps über Formulardaten bis hin zur Verwendung im API-Client demonstriert.

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

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Frontend TypeScript Types Skill

Zweck: Anleitung zur Erstellung von TypeScript-Typdefinitionen nach den bestehenden Mustern aus frontend/types/index.ts.

Überblick

Alle TypeScript-Typen sind in frontend/types/index.ts definiert. Die Typen entsprechen der Backend-API-Antwortstruktur und gewährleisten Typsicherheit in der gesamten Frontend-Anwendung.

Typmuster aus frontend/types/index.ts

1. Benutzertypen

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

Muster:

  • Verwende interface für Objekttypen
  • Markiere optionale Felder mit ?
  • Verwende extends für Typvererbung
  • Verwende camelCase für Frontend-Typen (auch wenn das Backend snake_case verwendet)

2. Aufgabentypen

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

Muster:

  • Verwende type für Union-Typen (String-Literale)
  • Verwende interface für Objekttypen
  • Stimme mit Backend-Feldnamen überein (snake_case für API-Felder wie user_id, due_date, created_at)
  • Erstelle separate Typen für Formulardaten (alle optional außer Pflichtfeldern)
  • Erstelle separate Typen für Abfrageparameter (alle optional)

3. API-Antworttypen

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

Muster:

  • Verwende generische Typen <T> für wiederverwendbare Strukturen
  • Gib einen Standard-Typ-Parameter an (<T = unknown>)
  • Füge ein success-Boolean-Flag hinzu
  • Füge optionale Felder data, message und error hinzu
  • Erstelle einen separaten Typ für paginierte Antworten mit dem meta-Objekt

4. Authentifizierungstypen

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

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

Muster:

  • Füge ein success-Boolean hinzu
  • Füge einen token-String hinzu
  • Füge ein user-Objekt (User-Typ) hinzu
  • Füge einen expiresAt-Zeitstempel für die Sitzung hinzu

5. Fehlertypen

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

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

Muster:

  • Verwende interface für Fehlerobjekte
  • Markiere optionale Felder mit ?
  • Verwende die Index-Signatur [key: string] für dynamische Objekttypen (FormErrors)

6. UI-Typen

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

Muster:

  • Verwende type für Union-Typen (String-Literale)
  • Verwende interface für Objekttypen
  • Füge eine eindeutige id zur Identifikation hinzu
  • Markiere optionale Felder mit ?

7. Export-/Importtypen

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

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

Muster:

  • Verwende type für Union-Typen (String-Literale)
  • Verwende interface für Ergebnisobjekte
  • Füge Zähler für Erfolg/Fehlerverfolgung hinzu
  • Füge ein optionales Array mit Fehlerdetails hinzu

Namenskonventionen für Typen

Interfaces

  • PascalCase: User, Task, ApiResponse
  • Beschreibende Namen: TaskFormData, UserSignupData

Typen (Union Types)

  • PascalCase: TaskStatus, TaskPriority, LoadingState
  • Beschreibende Namen: ToastType, ExportFormat

Props-Typen

  • Komponentenname + Props: TaskItemProps, ProtectedRouteProps
  • Beispiel: interface TaskItemProps { task: Task; }

Formulardatentypen

  • Entitätsname + FormData: TaskFormData, UserSignupData
  • Beispiel: interface TaskFormData { title: string; description?: string; }

Abfrageparametertypen

  • Entitätsname + QueryParams: TaskQueryParams
  • Beispiel: interface TaskQueryParams { status?: "all" | "pending" | "completed"; }

Übereinstimmung mit dem Backend-Schema

Feldnamen-Zuordnung

Backend (snake_case) → Frontend (camelCase für Formulardaten, snake_case für API-Antwort)

// Backend-API-Antwort (stimmt exakt mit Backend überein)
export interface Task {
  id: number;
  user_id: string;        // snake_case vom Backend
  title: string;
  due_date?: string;     // snake_case vom Backend
  created_at: string;    // snake_case vom Backend
  updated_at: string;    // snake_case vom Backend
}

// Frontend-Formulardaten (camelCase für einfachere Verwendung)
export interface TaskFormData {
  title: string;
  dueDate?: string;      // camelCase für Frontend
  tags?: string[];
}

Muster:

  • API-Antworttypen stimmen exakt mit dem Backend überein (snake_case)
  • Formulardatentypen verwenden camelCase für einfachere Frontend-Nutzung
  • Konvertiere zwischen den Formaten beim Senden/Empfangen von der API

Erforderliche vs. optionale Felder

// Backend-API-Antwort (alle Felder vom Backend)
export interface Task {
  id: number;              // Erforderlich (vom Backend)
  user_id: string;         // Erforderlich (vom Backend)
  title: string;           // Erforderlich (vom Backend)
  description?: string;    // Optional (vom Backend)
  completed: boolean;      // Erforderlich (vom Backend)
  priority: TaskPriority;  // Erforderlich (vom Backend)
  due_date?: string;       // Optional (vom Backend)
  tags: string[];          // Erforderlich (vom Backend, kann leeres Array sein)
  created_at: string;      // Erforderlich (vom Backend)
  updated_at: string;      // Erforderlich (vom Backend)
}

// Frontend-Formulardaten (nur Felder, die der Benutzer bearbeiten kann)
export interface TaskFormData {
  title: string;           // Erforderlich (Benutzer muss bereitstellen)
  description?: string;    // Optional
  priority?: TaskPriority;  // Optional (hat Standardwert)
  due_date?: string;       // Optional
  tags?: string[];         // Optional (kann leeres Array sein)
}

Muster:

  • API-Antworttypen enthalten alle Felder vom Backend
  • Formulardatentypen enthalten nur Felder, die der Benutzer bearbeiten kann
  • Markiere optionale Felder mit ?
  • Erforderliche Felder haben kein ?

Muster für Typstrukturen

1. Verwende interface für Objekte

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

Wann verwenden: Objekttypen mit Eigenschaften

2. Verwende type für Unions, Schnittmengen oder Aliasse

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

Wann verwenden: Union-Typen, Schnittmengen oder Typ-Aliasse

3. Verwende generische Typen für wiederverwendbare Strukturen

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

Wann verwenden: Wiederverwendbare Strukturen, die mit verschiedenen Typen arbeiten

4. Markiere optionale Eigenschaften mit ?

export interface Task {
  title: string;        // Erforderlich
  description?: string; // Optional
}

Wann verwenden: Felder, die möglicherweise nicht existieren

Vollständiges Beispiel: Hinzufügen neuer Typen

Schritt 1: Entitätstyp definieren (entspricht Backend)

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

Schritt 2: Formulardatentyp definieren (für Benutzereingaben)

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

Schritt 3: Abfrageparametertyp definieren (für API-Abfragen)

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

Schritt 4: Im API-Client verwenden

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

Verfassungsanforderungen

  • FR-030: Typisierte TypeScript-Interfaces für alle API-Aufrufe ✅
  • FR-037: TypeScript strict mode ✅

Referenzen

  • Spezifikation: specs/002-frontend-todo-app/spec.md - Entitätsdefinitionen
  • Plan: specs/002-frontend-todo-app/plan.md - API-Verträge mit Typen
  • Typendatei: frontend/types/index.ts - Vollständige Typdefinitionen

Zusammenfassung der gängigen Muster

  1. ✅ Verwende interface für Objekttypen
  2. ✅ Verwende type für Union-Typen (String-Literale)
  3. ✅ Verwende generische Typen <T> für wiederverwendbare Strukturen
  4. ✅ Markiere optionale Felder mit ?
  5. ✅ Stimme mit Backend-Feldnamen überein (snake_case für API-Antworten)
  6. ✅ Verwende camelCase für Formulardatentypen
  7. ✅ Erstelle separate Typen für Formulardaten und Abfrageparameter
  8. ✅ Verwende beschreibende Namen (EntityFormData, EntityQueryParams)
  9. ✅ Füge alle erforderlichen Felder vom Backend hinzu
  10. ✅ Gib Standard-Typ-Parameter für Generika an (<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

Verwandte Skills