🎯

react-component

🎯Skill

from bumgeunsong/daily-writing-friends

VibeIndex|
What it does

Generates React component boilerplate with structured imports, hooks, and TypeScript patterns for consistent and scalable frontend development.

πŸ“¦

Part of

bumgeunsong/daily-writing-friends(12 items)

react-component

Installation

git cloneClone repository
git clone https://github.com/BumgeunSong/daily-writing-friends.git
npm runRun npm script
npm run dev
πŸ“– Extracted from docs: bumgeunsong/daily-writing-friends
1Installs
-
AddedFeb 4, 2026

Skill Details

SKILL.md

Use when creating or modifying React components (.tsx files). Enforces component structure, import order, and hooks patterns.

Overview

# React Component Patterns

Component Structure

Follow this order in every component file:

```typescript

// 1. External imports

import { useState } from 'react';

import { useQuery } from '@tanstack/react-query';

// 2. Internal shared imports

import { Button } from '@/shared/ui/button';

import { useAuth } from '@/shared/hooks/useAuth';

// 3. Feature-specific imports

import { usePostEditor } from '../hooks/usePostEditor';

// 4. Types

interface PostEditorProps {

boardId: string;

initialContent?: string;

}

// 5. Component

export function PostEditor({ boardId, initialContent }: PostEditorProps) {

// hooks first

// derived state

// handlers

// render

}

```

Custom Hooks Pattern

Place business logic in [feature]/hooks/:

```typescript

import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';

import { createPost } from '../api/post';

export function usePostEditor(boardId: string) {

const queryClient = useQueryClient();

const createMutation = useMutation({

mutationFn: (data: CreatePostData) => createPost(boardId, data),

onSuccess: () => {

queryClient.invalidateQueries({ queryKey: ['posts', boardId] });

},

});

return { createMutation };

}

```

Path Aliases

```typescript

import { Component } from '@/shared/components/Component';

import { useHook } from '@board/hooks/useHook';

import { Post } from '@post/model/Post';

// Available: @/, @board/, @post/, @comment/, @draft/,

// @notification/, @user/, @shared/, @login/, @stats/

```

Quick Reference

| Location | Purpose |

|----------|---------|

| [feature]/components/ | React components |

| [feature]/hooks/ | Custom hooks with business logic |

| [feature]/model/ | TypeScript types |

| @/shared/ui/ | shadcn/ui components |

| @/shared/hooks/ | Shared hooks |

More from this repository10

🎯
refactoring🎯Skill

Refactors code by extracting pure functions from side-effect-laden logic, enabling easier testing and maintainability.

🎯
code-style🎯Skill

Enforces clean, readable code by providing guidelines for function design, naming conventions, and code clarity principles.

🎯
testing🎯Skill

Enforces output-based testing of pure functions, guiding developers to write testable code by focusing on functional core transformations.

🎯
react-hook🎯Skill

I apologize, but I cannot generate a description without seeing the specific details about the "react-hook" skill from the repository. Could you provide more context or details about what this part...

🎯
pr-stacking🎯Skill

Enables developers to break large features into smaller, dependent PRs for incremental development and easier code reviews.

🎯
commit🎯Skill

Stages and commits git changes following specific Korean commit message guidelines for clean, meaningful version control.

🎯
daily-writing-friends-design🎯Skill

Provides a comprehensive design system for Daily Writing Friends, ensuring consistent UI components, styling, and accessibility across the application.

🎯
fetching-pr-comments🎯Skill

Retrieves and parses GitHub PR review comments for the current branch using GitHub CLI, enabling quick review of code-level feedback.

🎯
api-layer🎯Skill

Manages API interactions and request handling for the Daily Writing Friends application, facilitating communication between frontend and backend services.

🎯
firebase-functions🎯Skill

Streamlines Firebase Cloud Functions development with structured TypeScript patterns, error handling, and organized function implementations.