Communitygithub.com

프론트엔드 개발 패턴

React, Next.js, 상태 관리, 성능 최적화 및 UI 모범 사례를 위한 프론트엔드 개발 패턴

프론트엔드 개발 패턴란 무엇인가요?

이 스킬은 현대 프론트엔드 애플리케이션을 구축하기 위한 포괄적인 패턴 및 모범 사례 라이브러리입니다. React 및 Next.js에 중점을 두고, 컴포넌트 구성, 복합 컴포넌트, 렌더 프롭스, 사용자 정의 훅, Context + Reducer를 통한 상태 관리, useMemo 및 React.memo를 활용한 성능 최적화, 코드 분할 및 지연 로딩, @tanstack/react-virtual을 활용한 가상화 등 핵심 주제를 다룹니다. 또한 Framer Motion 애니메이션, 접근성 패턴(키보드 탐색, 포커스 관리), 그리고 오류 경계 및 폼 검증과 같은 실용적인 패턴을 제공하여 모든 수준의 프론트엔드 개발자가 더 유지보수 가능하고 확장 가능한 사용자 인터페이스를 만들 수 있도록 돕습니다.

지원 대상~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/Bamose/everything-codex-cli/frontend-patterns

즐겨 사용하는 AI에게 물어보기

이 에이전트 스킬이 미리 로드된 새 채팅을 엽니다.

문서

프론트엔드 개발 패턴은(는) 무엇을 하나요?

React, Next.js 및 성능이 뛰어난 사용자 인터페이스를 위한 최신 프론트엔드 패턴입니다.

컴포넌트 패턴

상속보다는 합성

// ✅ 좋은 예: 컴포넌트 합성
interface CardProps {
  children: React.ReactNode
  variant?: 'default' | 'outlined'
}

export function Card({ children, variant = 'default' }: CardProps) {
  return <div className={`card card-${variant}`}>{children}</div>
}

export function CardHeader({ children }: { children: React.ReactNode }) {
  return <div className="card-header">{children}</div>
}

export function CardBody({ children }: { children: React.ReactNode }) {
  return <div className="card-body">{children}</div>
}

// 사용법
<Card>
  <CardHeader>제목</CardHeader>
  <CardBody>내용</CardBody>
</Card>

복합 컴포넌트

interface TabsContextValue {
  activeTab: string
  setActiveTab: (tab: string) => void
}

const TabsContext = createContext<TabsContextValue | undefined>(undefined)

export function Tabs({ children, defaultTab }: {
  children: React.ReactNode
  defaultTab: string
}) {
  const [activeTab, setActiveTab] = useState(defaultTab)

  return (
    <TabsContext.Provider value={{ activeTab, setActiveTab }}>
      {children}
    </TabsContext.Provider>
  )
}

export function TabList({ children }: { children: React.ReactNode }) {
  return <div className="tab-list">{children}</div>
}

export function Tab({ id, children }: { id: string, children: React.ReactNode }) {
  const context = useContext(TabsContext)
  if (!context) throw new Error('Tab은 Tabs 내에서 사용되어야 합니다')

  return (
    <button
      className={context.activeTab === id ? 'active' : ''}
      onClick={() => context.setActiveTab(id)}
    >
      {children}
    </button>
  )
}

// 사용법
<Tabs defaultTab="overview">
  <TabList>
    <Tab id="overview">개요</Tab>
    <Tab id="details">세부사항</Tab>
  </TabList>
</Tabs>

렌더 프롭스 패턴

interface DataLoaderProps<T> {
  url: string
  children: (data: T | null, loading: boolean, error: Error | null) => React.ReactNode
}

export function DataLoader<T>({ url, children }: DataLoaderProps<T>) {
  const [data, setData] = useState<T | null>(null)
  const [loading, setLoading] = useState(true)
  const [error, setError] = useState<Error | null>(null)

  useEffect(() => {
    fetch(url)
      .then(res => res.json())
      .then(setData)
      .catch(setError)
      .finally(() => setLoading(false))
  }, [url])

  return <>{children(data, loading, error)}</>
}

// 사용법
<DataLoader<Market[]> url="/api/markets">
  {(markets, loading, error) => {
    if (loading) return <Spinner />
    if (error) return <Error error={error} />
    return <MarketList markets={markets!} />
  }}
</DataLoader>

사용자 정의 훅 패턴

상태 관리 훅

export function useToggle(initialValue = false): [boolean, () => void] {
  const [value, setValue] = useState(initialValue)

  const toggle = useCallback(() => {
    setValue(v => !v)
  }, [])

  return [value, toggle]
}

// 사용법
const [isOpen, toggleOpen] = useToggle()

비동기 데이터 가져오기 훅

interface UseQueryOptions<T> {
  onSuccess?: (data: T) => void
  onError?: (error: Error) => void
  enabled?: boolean
}

export function useQuery<T>(
  key: string,
  fetcher: () => Promise<T>,
  options?: UseQueryOptions<T>
) {
  const [data, setData] = useState<T | null>(null)
  const [error, setError] = useState<Error | null>(null)
  const [loading, setLoading] = useState(false)

  const refetch = useCallback(async () => {
    setLoading(true)
    setError(null)

    try {
      const result = await fetcher()
      setData(result)
      options?.onSuccess?.(result)
    } catch (err) {
      const error = err as Error
      setError(error)
      options?.onError?.(error)
    } finally {
      setLoading(false)
    }
  }, [fetcher, options])

  useEffect(() => {
    if (options?.enabled !== false) {
      refetch()
    }
  }, [key, refetch, options?.enabled])

  return { data, error, loading, refetch }
}

// 사용법
const { data: markets, loading, error, refetch } = useQuery(
  'markets',
  () => fetch('/api/markets').then(r => r.json()),
  {
    onSuccess: data => console.log('가져옴', data.length, '개 시장'),
    onError: err => console.error('실패:', err)
  }
)

디바운스 훅

export function useDebounce<T>(value: T, delay: number): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value)

  useEffect(() => {
    const handler = setTimeout(() => {
      setDebouncedValue(value)
    }, delay)

    return () => clearTimeout(handler)
  }, [value, delay])

  return debouncedValue
}

// 사용법
const [searchQuery, setSearchQuery] = useState('')
const debouncedQuery = useDebounce(searchQuery, 500)

useEffect(() => {
  if (debouncedQuery) {
    performSearch(debouncedQuery)
  }
}, [debouncedQuery])

상태 관리 패턴

Context + 리듀서 패턴

interface State {
  markets: Market[]
  selectedMarket: Market | null
  loading: boolean
}

type Action =
  | { type: 'SET_MARKETS'; payload: Market[] }
  | { type: 'SELECT_MARKET'; payload: Market }
  | { type: 'SET_LOADING'; payload: boolean }

function reducer(state: State, action: Action): State {
  switch (action.type) {
    case 'SET_MARKETS':
      return { ...state, markets: action.payload }
    case 'SELECT_MARKET':
      return { ...state, selectedMarket: action.payload }
    case 'SET_LOADING':
      return { ...state, loading: action.payload }
    default:
      return state
  }
}

const MarketContext = createContext<{
  state: State
  dispatch: Dispatch<Action>
} | undefined>(undefined)

export function MarketProvider({ children }: { children: React.ReactNode }) {
  const [state, dispatch] = useReducer(reducer, {
    markets: [],
    selectedMarket: null,
    loading: false
  })

  return (
    <MarketContext.Provider value={{ state, dispatch }}>
      {children}
    </MarketContext.Provider>
  )
}

export function useMarkets() {
  const context = useContext(MarketContext)
  if (!context) throw new Error('useMarkets는 MarketProvider 내에서 사용되어야 합니다')
  return context
}

성능 최적화

메모이제이션

// ✅ useMemo를 사용한 비용이 큰 계산
const sortedMarkets = useMemo(() => {
  return markets.sort((a, b) => b.volume - a.volume)
}, [markets])

// ✅ 자식에게 전달되는 함수에 useCallback 사용
const handleSearch = useCallback((query: string) => {
  setSearchQuery(query)
}, [])

// ✅ 순수 컴포넌트에 React.memo 사용
export const MarketCard = React.memo<MarketCardProps>(({ market }) => {
  return (
    <div className="market-card">
      <h3>{market.name}</h3>
      <p>{market.description}</p>
    </div>
  )
})

코드 분할 및 지연 로딩

import { lazy, Suspense } from 'react'

// ✅ 무거운 컴포넌트 지연 로딩
const HeavyChart = lazy(() => import('./HeavyChart'))
const ThreeJsBackground = lazy(() => import('./ThreeJsBackground'))

export function Dashboard() {
  return (
    <div>
      <Suspense fallback={<ChartSkeleton />}>
        <HeavyChart data={data} />
      </Suspense>

      <Suspense fallback={null}>
        <ThreeJsBackground />
      </Suspense>
    </div>
  )
}

긴 목록을 위한 가상화

import { useVirtualizer } from '@tanstack/react-virtual'

export function VirtualMarketList({ markets }: { markets: Market[] }) {
  const parentRef = useRef<HTMLDivElement>(null)

  const virtualizer = useVirtualizer({
    count: markets.length,
    getScrollElement: () => parentRef.current,
    estimateSize: () => 100,  // 예상 행 높이
    overscan: 5  // 추가로 렌더링할 항목 수
  })

  return (
    <div ref={parentRef} style={{ height: '600px', overflow: 'auto' }}>
      <div
        style={{
          height: `${virtualizer.getTotalSize()}px`,
          position: 'relative'
        }}
      >
        {virtualizer.getVirtualItems().map(virtualRow => (
          <div
            key={virtualRow.index}
            style={{
              position: 'absolute',
              top: 0,
              left: 0,
              width: '100%',
              height: `${virtualRow.size}px`,
              transform: `translateY(${virtualRow.start}px)`
            }}
          >
            <MarketCard market={markets[virtualRow.index]} />
          </div>
        ))}
      </div>
    </div>
  )
}

폼 처리 패턴

유효성 검사가 포함된 제어 폼

interface FormData {
  name: string
  description: string
  endDate: string
}

interface FormErrors {
  name?: string
  description?: string
  endDate?: string
}

export function CreateMarketForm() {
  const [formData, setFormData] = useState<FormData>({
    name: '',
    description: '',
    endDate: ''
  })

  const [errors, setErrors] = useState<FormErrors>({})

  const validate = (): boolean => {
    const newErrors: FormErrors = {}

    if (!formData.name.trim()) {
      newErrors.name = '이름은 필수입니다'
    } else if (formData.name.length > 200) {
      newErrors.name = '이름은 200자를 초과할 수 없습니다'
    }

    if (!formData.description.trim()) {
      newErrors.description = '설명은 필수입니다'
    }

    if (!formData.endDate) {
      newErrors.endDate = '종료일은 필수입니다'
    }

    setErrors(newErrors)
    return Object.keys(newErrors).length === 0
  }

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault()

    if (!validate()) return

    try {
      await createMarket(formData)
      // 성공 처리
    } catch (error) {
      // 오류 처리
    }
  }

  return (
    <form onSubmit={handleSubmit}>
      <input
        value={formData.name}
        onChange={e => setFormData(prev => ({ ...prev, name: e.target.value }))}
        placeholder="시장 이름"
      />
      {errors.name && <span className="error">{errors.name}</span>}

      {/* 다른 필드 */}

      <button type="submit">시장 만들기</button>
    </form>
  )
}

오류 경계 패턴

interface ErrorBoundaryState {
  hasError: boolean
  error: Error | null
}

export class ErrorBoundary extends React.Component<
  { children: React.ReactNode },
  ErrorBoundaryState
> {
  state: ErrorBoundaryState = {
    hasError: false,
    error: null
  }

  static getDerivedStateFromError(error: Error): ErrorBoundaryState {
    return { hasError: true, error }
  }

  componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {
    console.error('오류 경계가 잡음:', error, errorInfo)
  }

  render() {
    if (this.state.hasError) {
      return (
        <div className="error-fallback">
          <h2>문제가 발생했습니다</h2>
          <p>{this.state.error?.message}</p>
          <button onClick={() => this.setState({ hasError: false })}>
            다시 시도
          </button>
        </div>
      )
    }

    return this.props.children
  }
}

// 사용법
<ErrorBoundary>
  <App />
</ErrorBoundary>

애니메이션 패턴

Framer Motion 애니메이션

import { motion, AnimatePresence } from 'framer-motion'

// ✅ 목록 애니메이션
export function AnimatedMarketList({ markets }: { markets: Market[] }) {
  return (
    <AnimatePresence>
      {markets.map(market => (
        <motion.div
          key={market.id}
          initial={{ opacity: 0, y: 20 }}
          animate={{ opacity: 1, y: 0 }}
          exit={{ opacity: 0, y: -20 }}
          transition={{ duration: 0.3 }}
        >
          <MarketCard market={market} />
        </motion.div>
      ))}
    </AnimatePresence>
  )
}

// ✅ 모달 애니메이션
export function Modal({ isOpen, onClose, children }: ModalProps) {
  return (
    <AnimatePresence>
      {isOpen && (
        <>
          <motion.div
            className="modal-overlay"
            initial={{ opacity: 0 }}
            animate={{ opacity: 1 }}
            exit={{ opacity: 0 }}
            onClick={onClose}
          />
          <motion.div
            className="modal-content"
            initial={{ opacity: 0, scale: 0.9, y: 20 }}
            animate={{ opacity: 1, scale: 1, y: 0 }}
            exit={{ opacity: 0, scale: 0.9, y: 20 }}
          >
            {children}
          </motion.div>
        </>
      )}
    </AnimatePresence>
  )
}

접근성 패턴

키보드 탐색

export function Dropdown({ options, onSelect }: DropdownProps) {
  const [isOpen, setIsOpen] = useState(false)
  const [activeIndex, setActiveIndex] = useState(0)

  const handleKeyDown = (e: React.KeyboardEvent) => {
    switch (e.key) {
      case 'ArrowDown':
        e.preventDefault()
        setActiveIndex(i => Math.min(i + 1, options.length - 1))
        break
      case 'ArrowUp':
        e.preventDefault()
        setActiveIndex(i => Math.max(i - 1, 0))
        break
      case 'Enter':
        e.preventDefault()
        onSelect(options[activeIndex])
        setIsOpen(false)
        break
      case 'Escape':
        setIsOpen(false)
        break
    }
  }

  return (
    <div
      role="combobox"
      aria-expanded={isOpen}
      aria-haspopup="listbox"
      onKeyDown={handleKeyDown}
    >
      {/* 드롭다운 구현 */}
    </div>
  )
}

포커스 관리

export function Modal({ isOpen, onClose, children }: ModalProps) {
  const modalRef = useRef<HTMLDivElement>(null)
  const previousFocusRef = useRef<HTMLElement | null>(null)

  useEffect(() => {
    if (isOpen) {
      // 현재 포커스된 요소 저장
      previousFocusRef.current = document.activeElement as HTMLElement

      // 모달로 포커스 이동
      modalRef.current?.focus()
    } else {
      // 닫을 때 포커스 복원
      previousFocusRef.current?.focus()
    }
  }, [isOpen])

  return isOpen ? (
    <div
      ref={modalRef}
      role="dialog"
      aria-modal="true"
      tabIndex={-1}
      onKeyDown={e => e.key === 'Escape' && onClose()}
    >
      {children}
    </div>
  ) : null
}

상태 관리 라이브러리 패턴

Zustand

import { create } from 'zustand'

interface MarketStore {
  markets: Market[]
  selectedMarket: Market | null
  loading: boolean
  error: string | null
  fetchMarkets: () => Promise<void>
  selectMarket: (market: Market) => void
}

export const useMarketStore = create<MarketStore>((set) => ({
  markets: [],
  selectedMarket: null,
  loading: false,
  error: null,

  fetchMarkets: async () => {
    set({ loading: true, error: null })
    try {
      const response = await fetch('/api/markets')
      const markets = await response.json()
      set({ markets, loading: false })
    } catch (error) {
      set({ error: (error as Error).message, loading: false })
    }
  },

  selectMarket: (market) => set({ selectedMarket: market })
}))

// 사용법
function MarketPage() {
  const { markets, loading, selectedMarket, fetchMarkets, selectMarket } = useMarketStore()

  useEffect(() => {
    fetchMarkets()
  }, [fetchMarkets])

  if (loading) return <Loading />

  return (
    <div>
      <MarketList markets={markets} onSelect={selectMarket} />
      {selectedMarket && <MarketDetail market={selectedMarket} />}
    </div>
  )
}

Jotai

import { atom, useAtom } from 'jotai'

// 기본 아톰
const marketsAtom = atom<Market[]>([])
const selectedMarketIdAtom = atom<string | null>(null)

// 파생 아톰
const selectedMarketAtom = atom((get) => {
  const markets = get(marketsAtom)
  const selectedId = get(selectedMarketIdAtom)
  return markets.find(market => market.id === selectedId) || null
})

// 비동기 아톰
const fetchMarketsAtom = atom(
  null,
  async (_get, set) => {
    const response = await fetch('/api/markets')
    const markets = await response.json()
    set(marketsAtom, markets)
  }
)

// 사용법
function MarketView() {
  const [markets] = useAtom(marketsAtom)
  const [selectedMarket] = useAtom(selectedMarketAtom)
  const [, fetchMarkets] = useAtom(fetchMarketsAtom)

  useEffect(() => {
    fetchMarkets()
  }, [fetchMarkets])

  return (
    <div>
      <MarketList markets={markets} />
      {selectedMarket && <MarketDetail market={selectedMarket} />}
    </div>
  )
}

서버 사이드 렌더링 패턴

Next.js App Router 패턴

// app/markets/page.tsx
import { Metadata } from 'next'

interface MarketPageProps {
  params: { id: string }
  searchParams: { page?: string }
}

// ✅ 서버 컴포넌트
export default async function MarketsPage() {
  const markets = await fetchMarkets()

  return (
    <div>
      <h1>시장</h1>
      <MarketList data={markets} />
    </div>
  )
}

// ✅ 정적 메타데이터
export const metadata: Metadata = {
  title: '시장',
  description: '모든 시장 보기'
}

스트리밍 및 Suspense

import { Suspense } from 'react'

export default function DashboardPage() {
  return (
    <div>
      <h1>대시보드</h1>
      <Suspense fallback={<MarketsSkeleton />}>
        {/* 내부에서 await 하는 서버 컴포넌트 */}
        <MarketsSection />
      </Suspense>
      <Suspense fallback={<TrendingSkeleton />}>
        <TrendingSection />
      </Suspense>
    </div>
  )
}

서버 액션을 통한 데이터 변경

// app/markets/actions.ts
'use server'

import { revalidatePath } from 'next/cache'

export async function createMarket(formData: FormData) {
  const name = formData.get('name') as string
  const description = formData.get('description') as string

  // 유효성 검사
  if (!name || name.length > 200) {
    return { error: '유효하지 않은 이름' }
  }

  try {
    await db.market.create({ data: { name, description } })
    revalidatePath('/markets')
    return { success: true }
  } catch (error) {
    return { error: '시장을 생성하지 못했습니다' }
  }
}

// app/markets/new/page.tsx
export default function NewMarketPage() {
  return (
    <form action={createMarket}>
      <input name="name" placeholder="시장 이름" required />
      <textarea name="description" placeholder="설명" required />
      <button type="submit">시장 만들기</button>
    </form>
  )
}

테스트 패턴

컴포넌트 테스트

import { render, screen, fireEvent } from '@testing-library/react'
import userEvent from '@testing-library/user-event'

describe('MarketCard', () => {
  const mockMarket = {
    id: '1',
    name: '테스트 시장',
    description: '설명'
  }

  it('시장 이름과 설명을 렌더링합니다', () => {
    render(<MarketCard market={mockMarket} />)
    
    expect(screen.getByText('테스트 시장')).toBeInTheDocument()
    expect(screen.getByText('설명')).toBeInTheDocument()
  })

  it('클릭 시 onSelect를 호출합니다', async () => {
    const onSelect = jest.fn()
    render(<MarketCard market={mockMarket} onSelect={onSelect} />)
    
    await userEvent.click(screen.getByRole('button'))
    expect(onSelect).toHaveBeenCalledWith(mockMarket)
  })
})

통합 테스트

describe('MarketList', () => {
  const mockMarkets = [
    { id: '1', name: '시장 1', description: '설명 1' },
    { id: '2', name: '시장 2', description: '설명 2' }
  ]

  it('모든 시장을 렌더링합니다', () => {
    render(<MarketList markets={mockMarkets} />)
    
    expect(screen.getByText('시장 1')).toBeInTheDocument()
    expect(screen.getByText('시장 2')).toBeInTheDocument()
  })

  it('선택 시 selectedMarket을 업데이트합니다', async () => {
    render(<MarketsPage />)
    
    await userEvent.click(screen.getByText('시장 1'))
    
    expect(screen.getByText('선택된 시장: 시장 1')).toBeInTheDocument()
  })
})

사용자 정의 훅 테스트

import { renderHook, act } from '@testing-library/react'

describe('useDebounce', () => {
  beforeEach(() => {
    jest.useFakeTimers()
  })

  afterEach(() => {
    jest.useRealTimers()
  })

  it('지정된 지연 후에 값을 업데이트합니다', () => {
    const { result, rerender } = renderHook(
      ({ value, delay }) => useDebounce(value, delay),
      { initialProps: { value: '초기', delay: 500 } }
    )

    expect(result.current).toBe('초기')

    rerender({ value: '업데이트됨', delay: 500 })
    
    act(() => {
      jest.advanceTimersByTime(300)
    })
    expect(result.current).toBe('초기')

    act(() => {
      jest.advanceTimersByTime(200)
    })
    expect(result.current).toBe('업데이트됨')
  })
})

CSS 및 스타일링 패턴

CSS 모듈

// components/MarketCard.module.css
.card {
  border: 1px solid var(--border-color);
  border-radius: 8px;
  padding: 16px;
  transition: box-shadow 0.2s;
}

.card:hover {
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
}

.title {
  font-size: 1.25rem;
  font-weight: 600;
  margin-bottom: 8px;
}

.description {
  color: var(--text-secondary);
  line-height: 1.5;
}

// components/MarketCard.tsx
import styles from './MarketCard.module.css'

export function MarketCard({ market }: { market: Market }) {
  return (
    <div className={styles.card}>
      <h3 className={styles.title}>{market.name}</h3>
      <p className={styles.description}>{market.description}</p>
    </div>
  )
}

Tailwind CSS 유틸리티 구성

// ✅ 일관된 디자인을 위한 합성 유틸리티 함수
function cn(...classes: (string | boolean | undefined)[]) {
  return classes.filter(Boolean).join(' ')
}

interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
  variant?: 'primary' | 'secondary' | 'ghost'
  size?: 'sm' | 'md' | 'lg'
}

export function Button({ variant = 'primary', size = 'md', className, ...props }: ButtonProps) {
  return (
    <button
      className={cn(
        'rounded-lg font-medium transition-colors focus:outline-none focus:ring-2',
        {
          'bg-blue-600 text-white hover:bg-blue-700': variant === 'primary',
          'bg-gray-200 text-gray-900 hover:bg-gray-300': variant === 'secondary',
          'bg-transparent text-gray-600 hover:bg-gray-100': variant === 'ghost'
        },
        {
          'px-3 py-1.5 text-sm': size === 'sm',
          'px-4 py-2 text-base': size === 'md',
          'px-6 py-3 text-lg': size === 'lg'
        },
        className
      )}
      {...props}
    />
  )
}

Next.js 앱 라우터 모범 사례

서버 컴포넌트와 클라이언트 컴포넌트

// app/markets/[id]/page.tsx - 서버 컴포넌트 (기본값)
import { notFound } from 'next/navigation'
import MarketDetail from './MarketDetail'

interface PageProps {
  params: { id: string }
}

export default async function MarketPage({ params }: PageProps) {
  const market = await fetchMarket(params.id)

  if (!market) {
    notFound()
  }

  // 데이터는 서버에서 가져오고 클라이언트 컴포넌트에 props로 전달
  return <MarketDetail market={market} />
}

// app/markets/[id]/MarketDetail.tsx - 클라이언트 컴포넌트
'use client'

import { useState } from 'react'

export default function MarketDetail({ market }: { market: Market }) {
  const [isFollowing, setIsFollowing] = useState(false)

  return (
    <div>
      <h1>{market.name}</h1>
      <p>{market.description}</p>
      <button onClick={() => setIsFollowing(!isFollowing)}>
        {isFollowing ? '팔로우 중' : '팔로우'}
      </button>
    </div>
  )
}

데이터 가져오기 패턴

// ✅ 병렬 데이터 가져오기
export default async function DashboardPage() {
  // 데이터 가져오기 병렬 실행
  const [markets, user, trending] = await Promise.all([
    fetchMarkets(),
    fetchCurrentUser(),
    fetchTrending()
  ])

  return (
    <div>
      <MarketsList data={markets} />
      <UserProfile user={user} />
      <TrendingSection data={trending} />
    </div>
  )
}

// ✅ 조건부 데이터 가져오기
export default async function SearchPage({
  searchParams
}: {
  searchParams: { q?: string }
}) {
  // 쿼리가 있는 경우에만 데이터 가져오기
  const results = searchParams.q
    ? await searchMarkets(searchParams.q)
    : []

  return (
    <div>
      <SearchForm initialQuery={searchParams.q} />
      <SearchResults results={results} />
    </div>
  )
}

결론

이러한 프론트엔드 패턴은 확장 가능하고 유지보수 가능하며 성능이 뛰어난 사용자 인터페이스를 구축하기 위한 견고한 기반을 제공합니다. 주요 내용은 다음과 같습니다:

  • 컴포넌트 패턴: 재사용 가능한 UI를 위한 합성, 복합 컴포넌트 및 렌더 프롭스
  • 훅: 재사용 가능한 로직을 위한 useToggle, useQuery 및 useDebounce
  • 상태 관리: 예측 가능한 상태를 위한 Context + Reducer, Zustand 및 Jotai
  • 성능: 메모이제이션, 코드 분할 및 가상화
  • 서버 렌더링: Next.js App Router, 스트리밍 및 서버 액션
  • 테스트: 포괄적인 적용 범위를 위한 단위, 통합 및 훅 테스트
  • 접근성: 키보드 탐색 및 포커스 관리

항상 특정 사용 사례에 가장 적합한 패턴을 선택하고 복잡성을 지나치게 추상화하지 않도록 주의하세요.

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

관련 스킬