giuseppe-trisciuoglio/developer-kit

react-patterns

Provides comprehensive React 19 patterns for Server Components, Server Actions, useOptimistic, useActionState, useTransition, concurrent features, Suspense boundaries, and TypeScript integration.

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill react-patterns

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

React 19 Development Patterns

Overview

React 19 patterns for Next.js App Router, Server Actions, optimistic UI, and concurrent features. See Quick Reference for API summary and Examples for copy-paste patterns.

When to Use

  • Building React 19 applications with Next.js App Router
  • Implementing optimistic UI with useOptimistic or useTransition
  • Creating Server Actions with form validation
  • Migrating from class components to hooks
  • Optimizing concurrent rendering with React Compiler
  • Managing complex state with useReducer or custom hooks
  • Wrapping async operations in Suspense boundaries

Quick Reference

PatternHook / APIUse Case
Local stateuseStateSimple component state
Complex stateuseReducerMulti-action state machines
Side effectsuseEffectSubscriptions, data fetching
Shared stateuseContext / createContextCross-component data
DOM accessuseRefFocus, measurements, timers
PerformanceuseMemo / useCallbackExpensive computations
Non-urgent updatesuseTransitionSearch/filter on large lists
Defer expensive UIuseDeferredValueStale-while-updating
Read resourcesuse() (React 19)Promises and context in render
Optimistic UIuseOptimistic (React 19)Instant feedback on mutations
Form statususeFormStatus (React 19)Pending state in child components
Form stateuseActionState (React 19)Server action results
Auto-memoizationReact CompilerEliminates manual memo/callback

Instructions

  1. Identify Component Type: Determine if Server Component or Client Component is needed
  2. Select Hooks: Use appropriate hooks for state management and side effects
  3. Type Props: Define TypeScript interfaces for all component props
  4. Handle Async: Wrap data-fetching components in Suspense boundaries
  5. Optimize: Use React Compiler or manual memoization for expensive renders
  6. Handle Errors: Add ErrorBoundary for graceful error handling
  7. Validate Server Actions: Define Zod/schema validation, then test:
  • Submit invalid inputs → verify rejection
  • Submit valid inputs → verify success

Examples

Server Component with Client Interaction

tsx
// Server Component (default) — async, fetches data
async function ProductPage({ id }: { id: string }) {
  const product = await db.product.findUnique({ where: { id } });

  return (
    <div>
      <h1>{product.name}</h1>
      <AddToCartButton productId={product.id} />
    </div>
  );
}

// Client Component — handles interactivity
'use client';
function AddToCartButton({ productId }: { productId: string }) {
  const [isPending, startTransition] = useTransition();

  const handleAdd = () => {
    startTransition(async () => {
      await addToCart(productId);
    });
  };

  return (
    <button onClick={handleAdd} disabled={isPending}>
      {isPending ? 'Adding...' : 'Add to Cart'}
    </button>
  );
}

useOptimistic for Instant Feedback

tsx
'use client';
import { useOptimistic } from 'react';

function TodoList({ todos, addTodo }: { todos: Todo[]; addTodo: (t: Todo) => Promise<void> }) {
  const [optimisticTodos, addOptimisticTodo] = useOptimistic(
    todos,
    (state, newTodo: Todo) => [...state, { ...newTodo, pending: true }]
  );

  const handleSubmit = async (formData: FormData) => {
    const newTodo = { id: Date.now(), text: formData.get('text') as string };
    addOptimisticTodo(newTodo);  // Immediate UI update
    await addTodo(newTodo);      // Actual backend call
  };

  return (
    <form action={handleSubmit}>
      {optimisticTodos.map(todo => (
        <div key={todo.id} style={{ opacity: todo.pending ? 0.5 : 1 }}>
          {todo.text}
        </div>
      ))}
      <input type="text" name="text" />
      <button type="submit">Add</button>
    </form>
  );
}

Server Action with Form

tsx
// app/actions.ts
'use server';
import { z } from 'zod';
import { revalidatePath } from 'next/cache';

const schema = z.object({
  title: z.string().min(5),
  content: z.string().min(10),
});

export async function createPost(prevState: any, formData: FormData) {
  const parsed = schema.safeParse({
    title: formData.get('title'),
    content: formData.get('content'),
  });

  if (!parsed.success) {
    return { errors: parsed.error.flatten().fieldErrors };
  }

  await db.post.create({ data: parsed.data });
  revalidatePath('/posts');
  return { success: true };
}

// app/blog/new/page.tsx
'use client';
import { useActionState } from 'react';
import { createPost } from '../actions';

export default function NewPostPage() {
  const [state, formAction, pending] = useActionState(createPost, {});

  return (
    <form action={formAction}>
      <input name="title" placeholder="Title" />
      {state.errors?.title && <span>{state.errors.title[0]}</span>}
      <textarea name="content" placeholder="Content" />
      <button type="submit" disabled={pending}>
        {pending ? 'Publishing...' : 'Publish'}
      </button>
    </form>
  );
}

Custom Hook

tsx
export function useOnlineStatus() {
  const [isOnline, setIsOnline] = useState(true);

  useEffect(() => {
    function handleOnline() { setIsOnline(true); }
    function handleOffline() { setIsOnline(false); }

    window.addEventListener('online', handleOnline);
    window.addEventListener('offline', handleOffline);

    return () => {
      window.removeEventListener('online', handleOnline);
      window.removeEventListener('offline', handleOffline);
    };
  }, []);

  return isOnline;
}

useTransition for Non-Urgent Updates

tsx
function SearchableList({ items }: { items: Item[] }) {
  const [query, setQuery] = useState('');
  const [isPending, startTransition] = useTransition();
  const [filteredItems, setFilteredItems] = useState(items);

  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    setQuery(e.target.value);
    startTransition(() => {
      setFilteredItems(items.filter(i => i.name.toLowerCase().includes(e.target.value.toLowerCase())));
    });
  };

  return (
    <div>
      <input value={query} onChange={handleChange} />
      {isPending && <span>Filtering...</span>}
      <ul>{filteredItems.map(i => <li key={i.id}>{i.name}</li>)}</ul>
    </div>
  );
}

Best Practices

Server vs Client Decision

  • Start with Server Component (no directive needed)
  • Add 'use client' only for: hooks, browser APIs, event handlers

State Management

  • Keep state minimal — compute derived values during render, not in effects
  • Use useReducer for state with multiple related actions
  • Lift state up to the nearest common ancestor

Effects

  • Use effects only for external system synchronization
  • Always specify correct dependency arrays
  • Return cleanup functions for subscriptions and timers
  • Never mutate state directly — always create new references

Performance

  • With React Compiler: avoid manual useMemo, useCallback, memo
  • Without React Compiler: use useMemo for expensive computations, useCallback for stable callbacks
  • Use useTransition for low-priority state updates
  • Use stable IDs as list keys, not array indices

React 19 Specifics

  • Wrap use(promise) components in Suspense boundaries
  • Use useActionState for form-server action integration
  • Validate Server Action inputs — they are public endpoints
  • Pass serializable data from Server to Client Components

Constraints and Warnings

  • Server Components: Cannot use hooks, event handlers, or browser APIs
  • use() Hook: Can only be called during render, not in callbacks or effects
  • Server Actions: Must include 'use server' directive; always validate inputs
  • State Mutations: Never mutate state directly — always create new references
  • Effect Dependencies: Include all dependencies in useEffect dependency arrays
  • Memory Leaks: Always clean up subscriptions and event listeners in useEffect return

References

Consult these files for detailed patterns:

  • [references/hooks-patterns.md](references/hooks-patterns.md) — useState, useEffect, useRef, useReducer, custom hooks, common pitfalls
  • [references/component-patterns.md](references/component-patterns.md) — Props, composition, lifting state, context, compound components, error boundaries
  • [references/react19-features.md](references/react19-features.md) — use(), useOptimistic, useFormStatus, useActionState, Server Actions, Server Components, migration guide
  • [references/performance-patterns.md](references/performance-patterns.md) — React Compiler setup, useMemo, useCallback, useTransition, useDeferredValue, lazy loading
  • [references/typescript-patterns.md](references/typescript-patterns.md) — Typed props, generic components, event handlers, discriminated unions, context typing
  • [references/learn.md](references/learn.md) — Progressive learning guide from basics to advanced React 19
  • [references/reference.md](references/reference.md) — Complete API reference for all React hooks and component APIs

관련 작업

같은 저장소의 Skills

더 많은 Skills

모든 Skills
giuseppe-trisciuoglio
커뮤니티

drizzle-orm-patterns

Provides comprehensive Drizzle ORM patterns for schema definition, CRUD operations, relations, queries, transactions, and migrations. Proactively use for any Drizzle ORM development including defining database schemas, writing type-safe queries, implementing relations, managing transactions, and setting up migrations with Drizzle Kit. Supports PostgreSQL, MySQL, SQLite, MSSQL, and CockroachDB.

1시간 설치 수
3
GitHub Stars
372
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

tailwind-css-patterns

Provides comprehensive Tailwind CSS utility-first styling patterns including responsive design, layout utilities, flexbox, grid, spacing, typography, colors, and modern CSS best practices. Use when styling React/Vue/Svelte components, building responsive layouts, implementing design systems, or optimizing CSS workflow.

1시간 설치 수
1
GitHub Stars
372
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

dynamodb-toolbox-patterns

Provides TypeScript patterns for DynamoDB-Toolbox v2 including schema/table/entity modeling, .build() command workflow, query/scan access patterns, batch and transaction operations, and single-table design with computed keys. Use when implementing type-safe DynamoDB access layers with DynamoDB-Toolbox v2 in TypeScript services or serverless applications.

1시간 설치 수
1
GitHub Stars
371
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

spring-boot-dependency-injection

Provides dependency injection patterns for Spring Boot projects, including constructor-first design, optional collaborator handling, bean selection, and wiring validation. Use when creating services and configurations, replacing field injection, or troubleshooting ambiguous or fragile Spring wiring.

1시간 설치 수
1
GitHub Stars
371
업데이트
9월 10일