first commit

This commit is contained in:
dahyeon committed 2025-11-07 02:50:20 +09:00
commit 120f150ee3
40 files changed
+7839

No files matched your search

+24
View File
@@ -0,0 +1,24 @@
# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
pnpm-debug.log*
lerna-debug.log*
node_modules
dist
dist-ssr
*.local
# Editor directories and files
.vscode/*
!.vscode/extensions.json
.idea
.DS_Store
*.suo
*.ntvs*
*.njsproj
*.sln
*.sw?
+80
View File
@@ -0,0 +1,80 @@
# Personal Wiki SPA
Microsoft Learn 스타일의 다크 테마 개인 위키 애플리케이션입니다.
## 기술 스택
- **프론트엔드**: React 19+ with TypeScript
- **빌드 도구**: Vite 7.1+
- **상태 관리**: TanStack React Query 5.90.7
- **라우팅**: React Router v7
- **UI 컴포넌트**: Radix UI (접근성 지원)
- **스타일링**: Tailwind CSS v4
- **아키텍처**: Feature-Sliced Design (FSD)
## 주요 기능
- ✅ 위키 페이지 CRUD (생성, 읽기, 수정, 삭제)
- ✅ Microsoft Learn 스타일의 3단 레이아웃
- ✅ 왼쪽 네비게이션 사이드바 (페이지 트리 + 실시간 검색)
- ✅ 오른쪽 목차 사이드바 (TOC)
- ✅ Breadcrumb 네비게이션
- ✅ 다크 테마 UI
- ✅ 접근성 지원 (Radix UI)
- ✅ 클라이언트 사이드 더미 데이터
## 프로젝트 구조 (FSD)
```
src/
├── app/ # 애플리케이션 엔트리 포인트
├── entities/ # 비즈니스 도메인 모델
│ └── page/ # Page 엔티티 (타입, API)
├── features/ # 재사용 가능한 기능 모듈
│ ├── page/ # 페이지 관련 UI 컴포넌트
│ └── search/ # 검색 기능
├── pages/ # 라우팅 대상 페이지 컴포넌트
├── shared/ # 공용 모듈
└── main.tsx # 진입점
```
## 시작하기
### 설치
```bash
npm install
```
### 개발 서버 실행
```bash
npm run dev
```
애플리케이션이 http://localhost:5173/ 에서 실행됩니다.
### 빌드
```bash
npm run build
```
### 프리뷰
```bash
npm run preview
```
## 사용 방법
1. **페이지 목록**: 메인 화면에서 모든 위키 페이지를 확인할 수 있습니다.
2. **검색**: 상단 검색바에서 페이지 제목이나 내용으로 검색할 수 있습니다.
3. **새 페이지 만들기**: "새 페이지" 버튼을 클릭하여 새로운 위키 페이지를 작성합니다.
4. **페이지 보기**: 목록에서 페이지를 클릭하여 상세 내용을 확인합니다.
5. **페이지 편집**: 페이지 상세 화면에서 "편집" 버튼을 클릭합니다.
6. **페이지 삭제**: 페이지 상세 화면에서 "삭제" 버튼을 클릭하고 확인합니다.
## 라이센스
MIT
+75
View File
@@ -0,0 +1,75 @@
# React + TypeScript + Vite
This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
Currently, two official plugins are available:
- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) (or [oxc](https://oxc.rs) when used in [rolldown-vite](https://vite.dev/guide/rolldown)) for Fast Refresh
- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
## React Compiler
The React Compiler is enabled on this template. See [this documentation](https://react.dev/learn/react-compiler) for more information.
Note: This will impact Vite dev & build performances.
## Expanding the ESLint configuration
If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
```js
export default defineConfig([
globalIgnores(['dist']),
{
files: ['**/*.{ts,tsx}'],
extends: [
// Other configs...
// Remove tseslint.configs.recommended and replace with this
tseslint.configs.recommendedTypeChecked,
// Alternatively, use this for stricter rules
tseslint.configs.strictTypeChecked,
// Optionally, add this for stylistic rules
tseslint.configs.stylisticTypeChecked,
// Other configs...
],
languageOptions: {
parserOptions: {
project: ['./tsconfig.node.json', './tsconfig.app.json'],
tsconfigRootDir: import.meta.dirname,
},
// other options...
},
},
])
```
You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
```js
// eslint.config.js
import reactX from 'eslint-plugin-react-x'
import reactDom from 'eslint-plugin-react-dom'
export default defineConfig([
globalIgnores(['dist']),
{
files: ['**/*.{ts,tsx}'],
extends: [
// Other configs...
// Enable lint rules for React
reactX.configs['recommended-typescript'],
// Enable lint rules for React DOM
reactDom.configs.recommended,
],
languageOptions: {
parserOptions: {
project: ['./tsconfig.node.json', './tsconfig.app.json'],
tsconfigRootDir: import.meta.dirname,
},
// other options...
},
},
])
```
+23
View File
@@ -0,0 +1,23 @@
import js from '@eslint/js'
import globals from 'globals'
import reactHooks from 'eslint-plugin-react-hooks'
import reactRefresh from 'eslint-plugin-react-refresh'
import tseslint from 'typescript-eslint'
import { defineConfig, globalIgnores } from 'eslint/config'
export default defineConfig([
globalIgnores(['dist']),
{
files: ['**/*.{ts,tsx}'],
extends: [
js.configs.recommended,
tseslint.configs.recommended,
reactHooks.configs['recommended-latest'],
reactRefresh.configs.vite,
],
languageOptions: {
ecmaVersion: 2020,
globals: globals.browser,
},
},
])
+18
View File
@@ -0,0 +1,18 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<link rel="icon" type="image/svg+xml" href="/vite.svg" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>wiki</title>
<!-- Google Fonts -->
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Asta+Sans:wght@300..800&family=Chiron+GoRound+TC:wght@200..900&family=Gothic+A1&family=Gowun+Batang&family=Gowun+Dodum&family=Noto+Sans+KR:wght@100..900&family=Noto+Serif+KR:wght@200..900&display=swap" rel="stylesheet">
</head>
<body>
<div id="root"></div>
<script type="module" src="/src/main.tsx"></script>
</body>
</html>
+5241
View File
File diff suppressed because it is too large. Load diff
+50
View File
@@ -0,0 +1,50 @@
{
"name": "wiki",
"private": true,
"version": "0.0.0",
"type": "module",
"scripts": {
"dev": "vite",
"build": "tsc -b && vite build",
"lint": "eslint .",
"preview": "vite preview"
},
"dependencies": {
"@lexical/code": "^0.38.2",
"@lexical/link": "^0.38.2",
"@lexical/list": "^0.38.2",
"@lexical/react": "^0.38.2",
"@lexical/rich-text": "^0.38.2",
"@lexical/selection": "^0.38.2",
"@lexical/table": "^0.38.2",
"@lexical/utils": "^0.38.2",
"@radix-ui/react-alert-dialog": "^1.1.15",
"@radix-ui/react-dialog": "^1.1.15",
"@radix-ui/react-icons": "^1.3.2",
"@radix-ui/react-label": "^2.1.8",
"@tanstack/react-query": "^5.90.7",
"lexical": "^0.38.2",
"react": "^19.1.1",
"react-dom": "^19.1.1",
"react-router-dom": "^7.9.5"
},
"devDependencies": {
"@eslint/js": "^9.36.0",
"@tailwindcss/postcss": "^4.1.16",
"@types/node": "^24.6.0",
"@types/react": "^19.1.16",
"@types/react-dom": "^19.1.9",
"@vitejs/plugin-react": "^5.0.4",
"autoprefixer": "^10.4.21",
"babel-plugin-react-compiler": "^19.1.0-rc.3",
"eslint": "^9.36.0",
"eslint-plugin-react-hooks": "^5.2.0",
"eslint-plugin-react-refresh": "^0.4.22",
"globals": "^16.4.0",
"postcss": "^8.5.6",
"tailwindcss": "^4.1.16",
"typescript": "~5.9.3",
"typescript-eslint": "^8.45.0",
"vite": "^7.1.7"
}
}
+6
View File
@@ -0,0 +1,6 @@
export default {
plugins: {
'@tailwindcss/postcss': {},
autoprefixer: {},
},
}
+190
View File
@@ -0,0 +1,190 @@
Personal Wiki SPA – Product Requirements Document
Overview
이 문서는 개인 위키 (Wiki) Single Page Application (SPA) 프로젝트의 제품 요구 사항과 구현 계획을 정리한 것입니다. 이 애플리케이션은 React 및 TypeScript로 구축되며, Vite를 기반으로 설정되었습니다. 사용자는 자체 위키 페이지를 생성, 편집, 삭제할 수 있고, 작성된 페이지들을 검색할 수 있습니다. UI는 Microsoft Learn과 같은 공식 문서 스타일의 단순하고 가독성 높은 디자인을 지향합니다. 접근성을 고려하여 Radix UI 라이브러리를 활용하고, Tailwind CSS로 UI 스타일링을 수행합니다. 데이터 관리와 API 연동은 TanStack React Query v5.90.7을 통해 처리하며, 현재 단계에서는 더미 데이터와 가짜 API로 클라이언트 사이드에서 동작하도록 합니다. 프로젝트 구조는 Feature-Sliced Design (FSD) 아키텍처 원칙을 준수하여 기능 단위로 모듈화됩니다[1][2].
Goals (목표)
• 위키 페이지 CRUD: 사용자가 위키 페이지를 생성(Create), 읽기(Read), 편집(Update) 및 삭제(Delete)할 수 있는 기본 기능 제공.
• 검색 기능: 키워드로 페이지 제목이나 내용을 검색하여 빠르게 찾아볼 수 있는 기능 제공.
• 사용자 경험: Official 문서처럼 깔끔하고 일관된 UI/UX 제공. 반응형 디자인으로 다양한 화면 크기에서 가독성 유지.
• 프론트엔드 아키텍처: Feature-Sliced Design에 따라 폴더 구조를 기능 중심으로 조직화하여 유지보수성과 확장성 확보[1]. 또한, TanStack React Query를 통한 효율적인 서버 상태 관리로 데이터 페칭/캐싱 최적화 및 코드 단순화를 달성[3].
• 접근성과 성능: Radix UI의 접근성 높은 컴포넌트를 활용하여 사용자 인터랙션 (모달 등)에 표준 준수 및 접근성 확보[4]. CSR(Client-Side Rendering) SPA로 사용자 입력에 빠르게 반응.
Non-Goals (범위에서 제외되는 항목)
• 사용자 인증: 로그인/권한 관리 등 사용자 인증 기능은 구현하지 않습니다 (모든 사용자는 동일한 권한으로 간주).
• 버전 관리 및 고급 위키 기능: 페이지의 버전 이력 추적, 컨텐츠 역사 비교, 이미지/첨부파일 업로드 등의 복잡한 위키 부가 기능은 현재 범위에 포함하지 않습니다.
• 실제 백엔드 구현: 이 프로젝트에서는 서버 API와의 통신을 모방한 더미 데이터로 대체합니다. 따라서 백엔드 서비스, DB 연동, 배포 등의 사항은 고려하지 않습니다 (추후 실제 서버 연결 용이성을 위해 인터페이스만 구축).
• 다국어 지원: 기본적으로 하나의 언어(예: 한국어)로 위키 페이지를 작성한다고 가정하며, i18n 다국어 지원은 포함하지 않습니다.
Features and Requirements (기능 명세)
1. 페이지 관리 (Page Management CRUD)
• 페이지 생성: 사용자는 새로운 위키 페이지를 생성할 수 있습니다. 페이지 생성 시 제목(title)과 본문(content)을 입력받는 폼을 제공하며, “생성” 버튼으로 제출합니다. 제출 후 새 페이지가 저장되고 애플리케이션에 즉시 반영됩니다. 생성된 페이지는 고유 ID를 부여받고, 목록 및 검색에 노출됩니다.
• 페이지 보기: 저장된 위키 페이지를 화면에서 열람할 수 있습니다. 제목은 헤드라인으로 표시하고 본문 콘텐츠는 본문 영역에 표시합니다. 뷰 화면에서는 편집 및 삭제 작업을 수행할 수 있는 UI 버튼을 제공합니다. 라우팅을 지원하여, 각 페이지는 고유 URL (/pages/{id} 형태 등)로 접근 가능하게 합니다 (예: 즐겨찾기나 직접 URL로 접근 시 해당 페이지 표시).
• 페이지 편집: 기존 페이지의 제목과 본문을 수정할 수 있습니다. “편집” 버튼을 누르면 편집 폼이 나타나며, 현재 저장된 제목/내용을 편집할 수 있습니다. 수정 완료 후 “저장”하면 변경사항이 저장되고, 페이지 보기 화면에 갱신된 내용이 반영됩니다. 편집 중 “취소”를 선택하면 변경사항 없이 페이지 보기 화면으로 돌아갑니다.
• 페이지 삭제: 사용자는 페이지를 삭제할 수 있습니다. “삭제” 버튼을 클릭하면 한 번 더 확인을 받는 확인 대화상자(modal)를 표시하여 오작동을 방지합니다. 확인 시 해당 페이지를 삭제하고, 사용자에게 삭제 완료를 알린 뒤 페이지 목록 화면으로 리다이렉트합니다. 삭제된 페이지는 목록과 검색 결과에서 즉시 제거됩니다.
2. 검색 기능 (Search)
• 키워드 검색: 다수의 위키 페이지 중 원하는 정보를 빠르게 찾을 수 있도록 검색 바를 제공합니다. 사용자가 키워드를 입력하면 페이지 제목이나 내용에 해당 키워드가 포함된 페이지들을 필터링하여 목록으로 표시합니다. 검색은 실시간으로 수행되며(입력 시 즉시 필터링) 또는 검색 버튼 액션으로 구현합니다.
• 검색 결과 표시: 검색 키워드에 대응되는 페이지들의 제목 리스트를 보여주며, 각 결과 항목을 클릭하면 해당 페이지 보기로 이동합니다. 검색어에 맞는 결과가 없을 경우 “일치하는 페이지가 없습니다”와 같은 안내를 표시합니다.
• UX 고려사항: 검색어 입력란은 페이지 목록 화면 상단에 배치하거나 상단 네비게이션 바에 일괄 배치합니다. 사용자 편의를 위해 검색어를 입력 중에도 기존 페이지 목록을 필터링하여 보여주거나, 필요 시 엔터키로 검색 확정하는 방식을 지원합니다. 검색 기능도 React Query를 활용해 구현하되, 현재 단계에서는 클라이언트 측 더미 데이터를 대상으로 합니다.
Technical Architecture (기술 아키텍처)
Tech Stack
• 프론트엔드 프레임워크: React (버전 19+), TypeScript. Vite (버전 7.1+)를 사용하여 프로젝트를 부트스트랩하였으며, 개발 편의성과 빌드 속도를 위해 선택되었습니다.
• 언어 및 컴파일러: TypeScript로 구현하여 정적 타입 체크와 개발자 생산성을 높입니다. Vite + SWC 조합으로 빠른 HMR(Hot Module Reload)과 빌드 최적화를 활용합니다.
• 상태 관리 및 데이터 통신: TanStack React Query 5.90.7을 사용하여 서버 상태를 관리합니다. React Query는 데이터 페칭, 캐싱, 동기화, 업데이트 등을 간결한 코드로 손쉽게 구현하게 해주며[3], API 호출 결과를 캐시하여 불필요한 재요청을 방지하고 앱 성능을 향상시킵니다. React Query의 훅(useQuery, useMutation 등)을 통해 CRUD API와 검색 기능을 구현하고, 로딩/에러 상태도 일관성 있게 관리합니다.
• UI 컴포넌트 라이브러리: Radix UI를 도입하여 접근성이 보장된 기본 컴포넌트(Primitive)를 활용합니다. Radix UI는 스타일이 적용되지 않은(headless) 낮은 수준의 UI 구성 요소들을 제공하여 개발자가 Tailwind CSS로 자유롭게 꾸밀 수 있게 하면서도, 키보드 내비게이션, ARIA 레이블 등 접근성 로직이 내장되어 있습니다[4]. 예를 들어 페이지 삭제 확인 모달은 Radix UI의 AlertDialog 컴포넌트를 사용하여 구현함으로써, 포커스 트랩핑 및 스크린리더 지원 등 접근성 요소를 쉽게 확보합니다.
• 스타일링: Tailwind CSS를 사용해 UI 스타일을 구현합니다. Tailwind CSS의 유틸리티 클래스들을 통해 빠르게 스타일링하고, 디자인 시스템과 일관성을 유지합니다. 별도의 CSS 파일 대신 Tailwind config를 설정하여 테마 색상, 폰트 등을 정의하고, 필요한 경우 커스텀 클래스를 구성합니다. Official 문서 느낌의 심플한 레이아웃 (예: 넓은 여백, 명조계열 폰트, 선명한 헤딩 스타일 등)을 Tailwind를 통해 손쉽게 조정합니다.
• 라우팅: React Router (v6+)를 도입하여 SPA 내 클라이언트 사이드 라우팅을 관리합니다. 사용자가 여러 페이지를 탐색할 수 있도록, 주요 화면 (페이지 목록, 페이지 상세, 페이지 편집, 등)에 대해 라우트를 정의합니다. 각 페이지는 URL로 매핑되어 브라우저 뒤로가기/새로고침 시에도 일관된 화면을 보여줍니다.
• 프로젝트 구조: 기능 중심의 Feature-Sliced Design (FSD) 아키텍처를 적용합니다. FSD의 핵심은 프로젝트를 기능별(Feature)로 나누고, 계층(Layer)을 두어 역할을 분리하는 것입니다[1]. 본 프로젝트에서는 아래와 같은 폴더 계층을 갖습니다:
• src/app: 애플리케이션 엔트리 포인트와 전역 설정 (예: App.tsx, 라우터 및 QueryClient Provider 설정).
• src/entities: 애플리케이션의 비즈니스 도메인 모델을 정의합니다. 예를 들어 entities/page 폴더에는 Page 객체 인터페이스 정의와 더미 데이터 및 API 함수들이 포함됩니다. (FSD에서 entities는 비즈니스 객체 및 해당 로직을 캡슐화합니다.)
• src/features: 재사용 가능한 기능 모듈을 구현합니다. 예를 들어 features/page에는 페이지 목록이나 페이지 폼과 같이 Page와 관련된 UI 컴포넌트와 훅, 상태 로직 등이 들어가고, features/search에는 검색 바 컴포넌트와 관련 로직이 들어갑니다. 개별 Feature는 자체 폴더 구조를 가지며, 필요한 경우 내부에 ui (UI 컴포넌트), model (상태로직), api 등을 구분할 수 있습니다.
• src/pages: 라우팅 대상이 되는 페이지 컴포넌트를 관리합니다. 각 페이지 컴포넌트는 여러 features와 entities를 조합하여 하나의 완성된 화면(View)을 구성합니다. 예컨대 pages/PageListPage.tsx (전체 페이지 목록 화면), pages/PageDetailPage.tsx (단일 페이지 조회 화면), pages/PageEditPage.tsx (편집 화면) 등이 구현됩니다.
• src/shared: 프로젝트 전반에서 쓰이는 공용 모듈 (유틸리티 함수, 공통 컴포넌트 등)을 둡니다. 예를 들어 공통 레이아웃이나 버튼 컴포넌트, 혹은 공통 훅이 있다면 shared 밑에 두어 어느 feature에서도 import 할 수 있도록 합니다. 단, FSD 원칙에 따라 shared 요소의 남용을 피하고 꼭 필요한 경우에만 사용합니다.
이러한 구조를 통해 폴더별, 모듈별 Public API를 명확히 노출하고 (index 파일을 통해 export 제어) 계층 간 의존성 방향을 아래로만 흐르도록 제한합니다. 즉, 상위 계층(pages)은 하위 (features, entities, shared)를 참조할 수 있지만, entities가 features나 pages를 역으로 참조하지는 않습니다. 이를 통해 변경이 발생해도 영향 범위가 최소화되고, 기능 단위로 독립적인 개발과 테스트가 가능해집니다[2].
Data Model and API Design (데이터 모델 및 API 설계)
데이터 모델 – Page
애플리케이션의 주요 데이터 객체는 페이지(Page)입니다. 각 Page는 아래와 같은 속성을 가집니다:
- id (string): 페이지를 식별하는 고유 ID. (예: UUID 문자열 또는 간단한 슬러그)
- title (string): 페이지 제목. 목록 및 헤드라인에 표시되며, 검색에 사용됩니다.
- content (string): 페이지 내용 본문. 위키 페이지의 텍스트로, Markdown 또는 일반 텍스트 형식 (현재 단계에서는 서식 없는 텍스트로 간주).
- createdAt (Date or string timestamp): 페이지 생성 시각 (옵션, UI에는 쓰이지 않을 수 있으나 정렬이나 로그에 활용 가능).
- updatedAt (Date or string timestamp): 페이지 최종 수정 시각 (옵션).
참고: 현재 MVP 구현에서는 createdAt/updatedAt을 사용하지 않더라도, 추후 확장을 고려해 데이터 모델에 포함시켜 둡니다. 또한 작성자(author) 정보나 버전(version) 이력 등은 범위 밖이므로 포함하지 않습니다.
더미 데이터 (Dummy Data)
초기 상태에서 앱이 활용할 몇 개의 더미 페이지 데이터를 정의합니다. 예를 들어 애플리케이션 로드 시 아래와 같은 Page 목록을 하드코딩해둘 수 있습니다:
[
{
"id": "page-1",
"title": "Getting Started",
"content": "이것은 개인 위키의 시작 페이지입니다. 여기에 내용을 작성하세요."
},
{
"id": "page-2",
"title": "About This Wiki",
"content": "이 위키는 React와 TypeScript로 제작되었으며, Tailwind CSS로 스타일링되었습니다."
}
]
이 데이터는 클라이언트 내 메모리에 저장되며, 앱 구동 시 전역 상태로 들고 있거나 혹은 localStorage를 통해 지속성(persistence)을 부여할 수 있습니다. (초기 개발 단계에서는 하드코딩하고, 필요하면 localStorage 저장/로드 추가를 고려)
클라이언트 API (더미 API 구현)
실제 백엔드가 없으므로, 클라이언트 측에 가짜 API 모듈을 만들어 React Query 훅이 이 함수를 통해 데이터를 가져오도록 합니다. API 모듈 (src/entities/page/api.ts 등)에는 다음 함수들이 포함됩니다:
- getPages(): 모든 Page 목록을 반환. (예: Promise<Page[]>). 구현은 내부적으로 위의 더미 데이터 배열을 resolve하는 것으로 대체합니다.
- getPage(id): 특정 ID의 Page를 반환. (예: Promise<Page | undefined>). 더미 구현은 배열에서 해당 id를 가진 객체를 찾아 반환합니다. 만약 존재하지 않을 경우 undefined나 에러 throw.
- createPage(data): 새로운 Page를 생성. (예: Promise<Page> 반환). 전달된 title, content를 기반으로 새로운 Page 객체를 만들고 (id는 UUID 생성 또는 Date.now() 기반 unique string), 더미 데이터 배열에 추가합니다. 성공 시 생성된 Page를 반환합니다.
- updatePage(id, data): 기존 Page 수정. (예: Promise<Page>). 주어진 id의 Page 객체를 찾아 title과 content를 업데이트하고, updatedAt 타임스탬프를 갱신합니다. 성공 시 수정된 Page 객체 반환. 대상이 없으면 에러 또는 null 처리.
- deletePage(id): 페이지 삭제. (예: Promise<void>). 주어진 id의 Page를 배열에서 제거합니다. 성공 여부를 불리언이나 void로 표시.
각 함수는 실제 서버 통신 대용이므로, 약간의 지연을 주어 비동기 처리를 시뮬레이트합니다. (예: setTimeout으로 100~300ms 후 resolve). 이렇게 하면 React Query의 로딩 상태 및 캐싱 메커니즘을 테스트하기 용이합니다.
엔드포인트 설계 (참고용)
향후 실제 백엔드가 구현된다면, 아래와 같은 RESTful API 엔드포인트를 상정할 수 있습니다:
- GET /api/pages → 모든 페이지 조회 (쿼리 파라미터로 검색 키워드 지원 가능, 예: /api/pages?query=foo)
- GET /api/pages/{id} → 특정 페이지 상세 조회
- POST /api/pages → 페이지 생성 (Request Body로 title, content 등 전송)
- PUT /api/pages/{id} → 페이지 전체 수정 (Body로 title, content)
- DELETE /api/pages/{id} → 페이지 삭제
그러나 본 프런트엔드 프로젝트에서는 위 엔드포인트들을 클라이언트 내 더미 함수로 대체하며, 실제 HTTP 요청은 발생하지 않습니다. React Query의 사용 패턴만 실제와 동일하게 유지하여, 나중에 이 더미 함수를 Axios 등을 통한 실제 API 호출로 교체하기 쉽도록 합니다.
User Interface (사용자 인터페이스)
레이아웃 및 내비게이션
• 전역 레이아웃: 앱 상단에 고정된 헤더를 두어 프로젝트 명(예: “My Wiki”)을 표시하고, 우측에 검색 창을 배치합니다. 헤더는 Tailwind를 이용해 단순한 Top Nav Bar 형태로 구현합니다. 메인 콘텐츠 영역은 각 라우트별 화면이 표시되는 영역입니다.
• 페이지 목록 화면: 애플리케이션의 홈("/")에 해당하며, 위키 페이지들의 목록이 표시됩니다. 각 항목은 카드나 리스트 아이템 형태로 페이지 제목을 보여주고, 클릭 시 해당 페이지 상세보기로 이동합니다. 목록 상단에는 "새 페이지 만들기" 버튼을 배치하여, 클릭 시 페이지 생성 폼 화면으로 전환합니다. 또한 헤더의 검색 입력을 통해 목록이 필터링됩니다 (또는 별도의 검색 영역이 상단에 있을 수도 있음).
• 페이지 상세보기 화면: 선택된 특정 페이지의 내용을 보여주는 화면입니다. URL은 "/pages/:id" 형태로 라우팅됩니다. 제목을 큰 글자로 표시하고, 내용(content)을 단락으로 렌더링합니다. (Markdown이 지원된다면 Marked 같은 파서를 이용해 HTML로 변환해 표시할 수 있으나, 현재는 텍스트를 <p>로 출력). 이 화면 상단 또는 하단에 편집, 삭제 버튼이 제공됩니다. 사용자가 "편집"을 누르면 편집 화면("/pages/:id/edit")으로 이동하며, "삭제"를 누르면 삭제 확인 모달이 뜹니다.
• 페이지 생성/편집 화면: 새 페이지 생성 폼과 기존 페이지 편집 폼은 유사한 UI를 사용하므로, 하나의 폼 컴포넌트로 재사용합니다. 라우팅은 생성의 경우 "/pages/new", 편집은 "/pages/:id/edit"로 구분됩니다. 제목 입력 필드(<input type="text">)와 내용 입력 필드(<textarea> 멀티라인)을 제공하며, Tailwind CSS로 폼 스타일링을 깔끔하게 합니다. 폼 하단에 “저장” (생성의 경우 “생성”)과 “취소” 버튼이 있습니다. 취소 시 이전 페이지로 돌아가고, 저장 시 입력값에 대한 유효성 검사 후 API 호출을 트리거합니다. React Query의 useMutation을 사용하여 POST/PUT 더미 API를 호출하며, 완료되면 페이지 상세보기 화면으로 네비게이트하거나 목록으로 돌아갑니다 (상세보기 화면으로 이동하는 편이 사용자에게 즉시 결과를 확인시켜주므로 바람직).
• 페이지 삭제 흐름: 페이지 상세 화면에서 “삭제” 클릭 시 Radix UI의 AlertDialog 컴포넌트를 이용하여 모달 창을 띄웁니다. 모달에는 “정말 삭제하시겠습니까? 이 동작은 되돌릴 수 없습니다.” 등의 경고 메시지와 함께 "삭제 확인" 및 "취소" 버튼을 제공합니다. 모달 밖 영역 클릭이나 취소 클릭 시 모달을 닫습니다. 삭제 확인 버튼 클릭 시 deletePage API 호출(mutation)을 수행하고, 성공 시 모달을 닫은 뒤 토스트 알림 또는 사용자 피드백 (예: “삭제되었습니다”)을 보여준 후 페이지 목록 화면으로 이동시킵니다. (토스트 구현은 필수가 아니므로, 간단히 목록으로 리디렉션하는 것으로 충분할 수 있습니다.)
UI 요소 및 스타일 가이드
• 타이포그래피: Tailwind 프리셋을 활용하여 문서 느낌의 타이포그래피 스타일 적용. 예를 들어 제목(title)은 text-2xl font-bold 등으로 크고 굵게 표시, 본문은 text-base leading-relaxed로 가독성을 높임. 전체 레이아웃은 밝은 배경에 짙은 색 텍스트(다크모드 지원은 일단 제외).
• 버튼: 주요 액션 버튼(생성, 저장, 삭제 등)은 Tailwind의 유틸리티 클래스로 스타일링하되, Radix UI와 조합해 키보드 포커스 스타일 및 ARIA 레이블을 신경 씀. 예: <button class="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700 focus:outline-none focus:ring">저장</button> 형식으로 일관된 버튼 스타일 사용.
• 폼 입력: <input>과 <textarea> 등 폼 요소는 Tailwind 폼 리셋 클래스를 활용해 기본 브라우저 스타일을 제거하고 (@tailwind base에 포함된 form-elements resets), border와 padding 등을 준 깔끔한 input 스타일로 디자인. Radix UI의 <Label> 컴포넌트를 사용하여 접근성 있는 레이블 연결을 해줄 수 있습니다 (label 요소와 input의 id를 연결).
• 모달/다이얼로그: Radix UI의 Dialog/AlertDialog 사용 시, Tailwind로 오버레이 반투명 배경(bg-gray-800 bg-opacity-50 등)과 컨텐츠 카드(bg-white rounded shadow p-6 등)를 스타일링합니다. Radix UI는 모달이 열릴 때 focus를 트랩하고 ESC로 닫기 등을 기본 지원하므로, 이러한 부분을 그대로 활용합니다[5][6].
• 반응형 디자인: 작은 화면(모바일)에서는 목록이 한 줄씩 쌓이고, 검색바와 새 페이지 버튼 등은 상단에 블록 배치됩니다. 큰 화면에서는 목록을 카드 그리드로 보여주거나, 좌측에 목록 + 우측에 상세보기처럼 2열 레이아웃을 적용할 수 있지만, 우선 단순화된 단일 열(column) 레이아웃으로 구현합니다. Tailwind의 responsive 툴 (sm:, md: prefix 등)로 필요 시 스타일 조정 예정.
Implementation Plan (구현 작업 계획)
아래는 프로젝트를 단계별로 구현하기 위한 세부 Tasks 목록입니다. 각 작업은 논리적으로 구분되며, 순차적으로 진행합니다. _WindSurf Cascade_와 같은 AI 코딩 도구가 이 단계를 따라갈 수 있도록, 명확한 단위 작업으로 나열하였습니다.
1. Project Setup and Dependencies: 초기 프로젝트 설정 및 의존성 관리. Vite + React + TypeScript 템플릿으로 생성된 프로젝트가 있다고 가정합니다. 우선 필수 패키지를 추가 설치합니다: Tailwind CSS, PostCSS, Autoprefixer, Radix UI (필요한 컴포넌트 패키지들, 예: @radix-ui/react-dialog, @radix-ui/react-alert-dialog), TanStack React Query (@tanstack/react-query@5.90.7), React Router DOM. package.json에 명시된 버전(@types 포함)은 최신을 사용합니다. 작업 내용: npm install -D tailwindcss postcss autoprefixer 및 npx tailwindcss init으로 Tailwind 설정 파일 생성; npm install @radix-ui/react-dialog @radix-ui/react-alert-dialog @radix-ui/react-icons 등 Radix UI 패키지 설치; npm install @tanstack/react-query react-router-dom 등. 설치 후 애플리케이션을 실행하여 문제가 없는지 확인합니다.
2. Configure Tailwind CSS: Tailwind CSS를 프로젝트에 설정합니다. Tailwind 설정 파일(tailwind.config.js)을 열어 content 경로를 설정하고 (./index.html, ./src/**/*.{js,ts,jsx,tsx} 등), 필요한 Tailwind 플러그인 또는 테마 설정 (예: 폰트 패밀리, 컬러 팔레트 커스터마이징)이 있으면 추가합니다. 글로벌 CSS (src/index.css 또는 App.css)에 Tailwind 지시어를 추가합니다:
@tailwind base;
@tailwind components;
@tailwind utilities;
브라우저 기본 스타일과 Form 스타일을 리셋하기 위해 Tailwind Preflight가 적용되었는지 확인합니다. Tailwind가 제대로 적용되었는지 검증하기 위해 간단한 요소에 클래스 (예: <div class="text-red-500">Test</div>)를 넣어 화면에서 색상이 적용되는지 확인합니다.
3. Integrate Radix UI Library: Radix UI 컴포넌트를 사용할 준비를 합니다. 프로젝트에 Radix UI의 AlertDialog (삭제 확인에 사용), Dialog (필요시 생성/편집 폼 모달용), 그리고 Radix Icons (필요한 아이콘이 있을 경우) 등을 설치했으므로, 실제 사용을 위해 Radix UI의 스타일 가이드를 참고합니다. Radix는 기본적으로 언스타일드 컴포넌트를 제공하므로, Tailwind와 함께 사용할 예정입니다[4]. 작업 내용: Radix 컴포넌트 사용법 익히기 (예: AlertDialog 구성 요소 – <AlertDialog.Root>, <AlertDialog.Trigger>, <AlertDialog.Content> 등). 추후 구현 단계에서 바로 활용할 수 있도록, 간단한 테스트 컴포넌트를 만들어 Radix AlertDialog가 열리고 닫히는지 콘솔 로그로 확인해봅니다 (선택 사항). Radix UI 공식 사이트의 예제 코드를 참조하여 접근성 속성(ARIA 레이블 등)이 잘 적용되도록 유의합니다.
4. Establish Project Structure (FSD): Feature-Sliced Design 원칙에 따라 폴더 구조를 정리합니다. src/ 디렉토리 아래에 entities, features, pages, shared 폴더를 생성합니다. 각 폴더에는 index 파일을 만들어, 바깥에서 import 할 때 경로가 노출되지 않도록 encapsulation을 관리합니다.
5. src/entities/page/: 페이지 엔티티 관련 모델 정의와 데이터 액세스 코드. 예: types.ts에 Page 인터페이스 정의, api.ts에 더미 API 함수 (getPages, getPage, createPage, updatePage, deletePage) 선언 및 구현.
6. src/features/page/: 페이지 관련 UI와 로직. 예: PageList 컴포넌트 (PageList.tsx), PageItem.tsx (목록 내 개별 아이템), PageForm.tsx (생성/편집 폼), 그리고 해당 컴포넌트들의 스타일이나 훅을 넣을 수 있습니다. 기능별로 폴더를 더 세분화해도 되지만 현재 규모에선 하나의 폴더에 모아도 무방합니다.
7. src/features/search/: 검색바 UI 컴포넌트 (SearchBar.tsx) 및 관련 훅/로직. (간단한 프로젝트라 이 정도로 충분)
8. src/pages/: 라우트에 대응하는 페이지 컴포넌트. 예: PageListPage.tsx, PageDetailPage.tsx, PageEditPage.tsx. 이들은 주로 UI 배치를 담당하며, 내부에서 features의 컴포넌트를 조립해 화면을 구성합니다.
9. src/shared/: 프로젝트 전반에서 쓰일 수 있는 컴포넌트나 유틸. 예: 공통 레이아웃 컴포넌트 (컨테이너, 헤더 등), 공통 Button 컴포넌트 (필요시), 또는 shared/api (Fetch wrapper 등). 현재 단계에서는 크게 필요하지 않을 수 있으므로 최소한으로 유지합니다.
작업 내용: 위 구조대로 디렉토리를 만들고, 각 위치에 placeholder 파일들을 생성해둡니다 (예: 각 컴포넌트 파일에 기본적인 React 컴포넌트 뼈대 작성, 예: export const PageList = () => { return <div>PageList</div> } 등). 이렇게 하면 나중 단계에서 각각 구현할 때 구조가 갖춰져 있어 편리합니다. 또한, FSD 취지에 맞게 모듈간 의존성 규칙을 확인합니다: entities에는 UI 코드가 없고, features는 필요한 경우 entities를 import하여 데이터 사용, pages는 features와 entities를 조합, shared는 어디서나 import 가능하지만 핵심 비즈니스 로직은 담지 않음.
1. Implement Data Model & Dummy API: entities/page 폴더 내에 Page 데이터 모델과 더미 API를 구현합니다.
2. types.ts: Page 인터페이스 정의 (interface Page { id: string; title: string; content: string; createdAt?: string; updatedAt?: string }).
3. data.ts (선택): 초기 더미 데이터 배열 선언. 예: let pages: Page[] = [ {...}, {...} ];로 앞서 명시한 몇 개의 예시 데이터를 포함합니다.
4. api.ts: 위에서 설계한 getPages, getPage, createPage, updatePage, deletePage 함수를 구현합니다. 각 함수는 Promise를 반환하며, 내부에서 setTimeout으로 약간의 지연 후 resolve합니다.
o getPages(): return Promise.resolve(pages); (혹은 setTimeout으로 pages 반환).
o getPage(id): const page = pages.find(p => p.id === id); return Promise.resolve(page); (못 찾으면 Promise.reject하거나 resolve(undefined) 처리).
o createPage(data): { id: generateId(), ...data, createdAt: new Date().toISOString() } 형태로 객체 생성 후 pages.push()로 추가, 생성된 객체를 resolve. (ID 생성은 단순 Date.now().toString()이나 uuid 패키지 사용할 수 있으나, 의존성 줄이기 위해 간단히 구현).
o updatePage(id, data): const page = pages.find(...); 찾아서 page.title = data.title; page.content = data.content; page.updatedAt = new Date().toISOString(); 한 뒤 그 객체를 resolve. 못 찾으면 reject.
o deletePage(id): pages = pages.filter(p => p.id !== id); return Promise.resolve();.
각 함수는 오류 상황 (예: 존재하지 않는 ID 편집 등)에 대한 콘솔 경고나 예외 throw를 넣어두면 디버깅에 도움이 됩니다.
5. 유틸리티: Optionally, generateId() 함수를 만들어 (shared 폴더나 api.ts 내) 단순 unique ID 생성 (예: 'page-' + Math.random().toString(36).substr(2, 9)).
이렇게 구현한 더미 API는 실제 React Query와 연결되어 사용되므로, TypeScript 타입을 정확히 지정하여 훅에서 타입 추론이 제대로 되도록 합니다. (예: function getPages(): Promise<Page[]> { ... } 등 선언)
1. Initialize App Providers (React Query & Router): 애플리케이션의 엔트리 포인트 설정을 완료합니다. src/main.tsx (또는 src/App.tsx)에서 QueryClientProvider와 BrowserRouter를 설정합니다.
2. TanStack React Query: import { QueryClient, QueryClientProvider } from '@tanstack/react-query'; 한 뒤 const queryClient = new QueryClient(); 생성. 최상위 <QueryClientProvider client={queryClient}>로 App 컴포넌트를 감쌉니다. 이렇게 함으로써 하위에서 useQuery, useMutation 사용이 가능해집니다[7].
3. React Router: import { BrowserRouter, Routes, Route } from 'react-router-dom'; 추가. QueryClientProvider 내부에서 <BrowserRouter>로 라우터를 설정합니다. <Routes> 내에 각 path와 페이지 컴포넌트를 매핑합니다. 예:
<Routes>
<Route path="/" element={<PageListPage />} />
<Route path="/pages/new" element={<PageEditPage isNew={true} />} />
<Route path="/pages/:id" element={<PageDetailPage />} />
<Route path="/pages/:id/edit" element={<PageEditPage isNew={false} />} />
</Routes>
여기서 PageEditPage 컴포넌트는 isNew prop으로 생성/편집 모드를 구분하도록 설계했습니다. (Alternatively, 분리된 NewPage, EditPage 컴포넌트를 만들어도 됩니다.)
4. 전역 Context: 추후 페이지 간 상태 공유나 UI를 위해 React Context가 필요하다면 Context Provider를 추가할 수 있으나, 현재는 React Query가 데이터를 전역 캐시로 관리하므로 별도 Context는 사용하지 않습니다.
5. 작업 내용: App 초기 구조를 완성짓는 이 단계에서는 아직 각 Page 컴포넌트 내부 구현은 비워둘 수 있습니다. 라우팅이 제대로 동작하는지, 잘못된 경로 접근 시 등의 처리를 확인합니다 (추가로 <Route path="*"에 404 페이지를 만들 수 있지만 필수는 아님).
6. Implement Page List Page (All Pages List + Search): 홈 화면에 해당하는 페이지 목록 화면을 구현합니다. 이는 pages/PageListPage.tsx 컴포넌트로, 내부에서 features/page/PageList와 features/search/SearchBar 컴포넌트를 조합합니다.
7. 데이터 가져오기: React Query의 useQuery 훅을 사용하여 페이지 목록 데이터를 fetch합니다. useQuery(['pages'], getPages) 형태로 키를 'pages'로 주고, 앞서 구현한 getPages API 함수를 연결합니다. 컴포넌트가 마운트되면 pages 데이터를 불러와 캐시에 저장하고, 로딩 상태와 에러를 관리합니다.
8. 로딩/에러 처리: if (isLoading) ... 혹은 Skeleton UI, if (error) ... 오류 메시지 등을 적절히 표시합니다. (공식 문서 느낌을 위해 간략한 텍스트로 표기)
9. 페이지 리스트 표시: 데이터를 받으면 <ul> 혹은 <div> 리스트를 순회하여 각 페이지의 제목을 출력합니다. features/page/PageItem 컴포넌트를 만들어 각 아이템 (제목과 간략 내용 일부?)을 렌더링하고, 클릭하면 해당 페이지 상세로 이동하도록 링크 (<Link to={/pages/${id}}>)를 겉에 감싸줍니다. React Router의 <Link>를 이용하면 a태그 대신 SPA 내부 전환이 이루어집니다.
10. 검색 기능: 상단에 features/search/SearchBar 컴포넌트를 배치합니다. SearchBar는 내부에 <input type="text">를 갖고, onChange 시 상위 컴포넌트로 검색어를 알려주는 콜백 prop을 받을 수 있습니다. PageListPage에서 const [query, setQuery] = useState('')로 상태를 관리하고, SearchBar의 prop으로 onSearchChange={setQuery}를 전달합니다. 검색 구현을 간단히 하기 위해, 클라이언트 필터링을 우선 채택합니다: const filteredPages = data.filter(page => page.title.includes(query) || page.content.includes(query)). 그리고 이 filteredPages를 맵으로 렌더링합니다. (추후 실제 API 사용 시 getPages(query) 형태로 쿼리参数를 전달해 서버 필터링할 수 있음).
11. 새 페이지 버튼: 페이지 상단 또는 하단에 “+ 새 페이지” 버튼을 제공합니다. <Link to="/pages/new">새 페이지</Link> 형태로 구현하여 클릭 시 새 페이지 생성 폼으로 이동합니다. 이 버튼은 Tailwind로 스타일링하고, Radix UI의 <Button>이나 아이콘을 사용할 수 있습니다 (+ 아이콘 등 추가).
12. 작업 내용: PageListPage 구현 및 스타일링. SearchBar 컴포넌트는 <input>에 Tailwind 클래스로 적절한 스타일 (예: border p-2 rounded w-full)을 적용하고 placeholder로 "검색어를 입력하세요". SearchBar의 값을 controlled component로 관리하여, 상위에서 내려온 query 상태와 동기화합니다. 입력이 변경되면 setQuery를 호출해 PageListPage를 re-render하여 filteredPages가 갱신되도록 합니다.
13. 검증: 몇 개의 더미 데이터가 보이는지 확인하고, 검색란에 문자열을 넣었을 때 실시간으로 리스트가 줄어드는지 확인합니다. 없는 단어를 넣으면 빈 상태 표시하는지 검토합니다.
14. Implement Page Detail Page (View Page): 개별 페이지 내용을 보여주는 pages/PageDetailPage.tsx 컴포넌트를 구현합니다. React Router를 통해 경로 /pages/:id로 렌더링되며, useParams() 훅을 사용해 URL에서 id를 받아옵니다.
15. 데이터 가져오기: const { id } = useParams(); 한 후, React Query의 useQuery(['page', id], () => getPage(id))를 사용하여 해당 id의 페이지 데이터를 불러옵니다 (getPage는 앞서 만든 API 함수). 캐싱을 위해 키를 ['page', id]로 구분하였고, 이 데이터는 앞서 'pages' 리스트와 별도로 관리됩니다. (단, React Query가 기본으로 캐시해두므로, 만약 PageListPage에서 이미 전체 리스트를 불러왔다면, 개별 getPage 호출 없이도 캐시에서 찾아오는 최적화가 가능하지만 여기선 단순 구현).
16. UI 표시: 로딩 중이면 "불러오는 중..." 표시, 에러 발생 시 오류 메세지 표시. 데이터가 있으면 페이지 제목과 내용을 보여줍니다. 제목은 <h1 class="text-2xl font-bold mb-4">...</h1> 형식으로 표시하고, 내용은 줄바꿈 등을 유지하도록 <p class="whitespace-pre-line">...</p>로 출력하거나, Markdown 파싱을 고려할 경우 마크업 처리.
17. 편집/삭제 버튼: 페이지 내용 아래 혹은 위에 액션 버튼들을 배치합니다. Tailwind로 버튼 스타일을 지정하고, React Router <Link>로 편집 이동 (to={/pages/${id}/edit})를 설정합니다. 삭제 버튼은 클릭 이벤트 핸들러를 설정하여, AlertDialog 모달을 열도록 합니다.
18. Radix AlertDialog 통합: Radix UI의 AlertDialog를 PageDetailPage 내에서 사용하여 삭제 확인을 구현합니다. AlertDialog.Root로 감싸고, trigger는 삭제 버튼으로 설정 (<AlertDialog.Trigger asChild><button className="...">삭제</button></AlertDialog.Trigger>). 그리고 <AlertDialog.Content>에 모달 내용을 작성합니다: 경고 아이콘(선택), "이 페이지를 삭제하시겠습니까?" 등의 메시지, <AlertDialog.Action> 버튼 (실행), <AlertDialog.Cancel> 버튼 (취소). 스타일링은 Radix 공식 예제 참고하여 Tailwind 클래스 부여[8][9].
19. Delete Mutation: 삭제 확인 버튼 클릭 시 실제 삭제 로직을 실행해야 합니다. React Query의 useMutation(deletePage)를 사용하여 mutation 훅을 정의합니다:
const deleteMutation = useMutation(() => deletePage(id!), {
onSuccess: () => {
// invalidation and navigation
}
});
onSuccess에서는 React Query 캐시에서 페이지 리스트와 개별 페이지 데이터를 무효화합니다: e.g. queryClient.invalidateQueries(['pages']); queryClient.removeQueries(['page', id]);. 그리고 navigate("/")를 호출하여 목록 화면으로 리디렉션합니다. (React Router v6의 useNavigate 훅 사용).
20. 작업 내용: PageDetailPage에 위 내용들을 모두 조합합니다. 특히 AlertDialog는 별도 컴포넌트로 분리해도 되지만 (features로), 여기서는 PageDetailPage 내부에 직접 작성합니다. 삭제 버튼을 클릭하면 deleteMutation.mutate()를 호출하도록 onClick 또는 AlertDialog Action의 onSelect에 연결합니다. React Query의 mutation 상태 (isLoading, isError)를 관리하여, 삭제 진행중에는 버튼을 비활성화하거나 로딩 표시, 에러 시 alert 표시도 고려합니다.
21. Implement Page Form (Create & Edit): 페이지 생성과 편집을 담당하는 폼 컴포넌트를 구현합니다. features/page/PageForm.tsx로 만들고, 재사용할 수 있도록 입력 필드와 제출 로직을 포함합니다. 그리고 pages/PageEditPage.tsx (혹은 NewPage/EditPage)를 작성하여 PageForm을 사용합니다.
22. PageForm 컴포넌트: props로 initialData (Page 또는 undefined), onSubmit 콜백, isNew (boolean) 등을 받을 수 있습니다. 내부에 제목 입력 (<input value={title} onChange={...} />)과 내용 입력 (<textarea value={content} onChange={...} />)을 state로 관리합니다. initialData가 주어지면 해당 값으로 초기화하고, 없으면 빈 문자열로 시작합니다.
23. 유효성 검사: 제목은 필수, 너무 긴 경우 자를 수도 있음. 간단히 빈 값 체크 정도를 하고, 유효하지 않을 때는 버튼 비활성화 또는 오류 메시지 (예: "제목은 필수입니다")를 폼 상단에 표시합니다.
24. 저장 동작: 폼 제출 시 React Query useMutation을 사용하여 API 호출. const createMutation = useMutation(createPage, { onSuccess: ... }), const updateMutation = useMutation(updatePage, { onSuccess: ... }). PageForm 내부에서 isNew 여부에 따라 적절한 mutation 함수를 호출합니다. onSuccess 시:
o 생성의 경우: 새로 생성된 Page 객체를 받으면 navigate("/pages/[newId]")로 상세 페이지로 이동 (또는 페이지 목록으로 이동하고 success 토스트). 그리고 'pages' 리스트를 무효화하여 목록을 갱신시킵니다.
o 수정의 경우: 변경 사항이 이미 캐시에 반영되도록 queryClient.setQueryData(['page', id], updatedPage)를 하면 상세보기 즉시 반영 가능. 또한 'pages' 목록도 invalidate (목록에 제목 업데이트 반영 위해). 그리고 navigate(-1) 또는 navigate("/pages/{id}")로 돌아갑니다.
25. 취소 버튼: navigate(-1) 호출하여 이전 페이지로 돌아가도록 처리 (편집 → 상세, 생성 → 목록).
26. 스타일링: 폼 레이아웃은 <div className="max-w-xl mx-auto"> 등 가운데 정렬, 위에 제목 입력 (Label: "제목", Input 박스), 아래 본문 입력 (Label: "내용", Textarea 높이를 적당히). Tailwind로 폼 요소 스타일 지정 (border, rounded 등). Radix UI의 <Form> 컴포넌트는 사용하지 않아도 되지만, Radix의 <Label>을 사용할 수 있습니다: <Label htmlFor="title">제목</Label> 등.
27. pages/PageEditPage.tsx: 이 페이지 컴포넌트는 라우트로부터 id를 얻고, isNew 여부에 따라 동작 분기합니다. id가 있는 경우 편집이므로 React Query로 기존 데이터를 가져와 PageForm에 props로 전달합니다 (initialData=pageData). id가 없는 (예: path=="/pages/new") 경우 PageForm에 initialData={undefined}로 전달. PageEditPage는 PageForm 주위에 적절한 레이아웃이나 헤더 (예: "페이지 생성" 또는 "페이지 편집" 헤딩) 넣어줄 수 있습니다.
28. 작업 내용: PageForm의 state와 이벤트가 제대로 작동하도록 구현하고, PageEditPage에서 이를 사용. React Query mutation이 진행되는 동안 저장 버튼을 disabled 처리하고 "저장 중..." 인디케이터 (스피너 or 텍스트) 보여주기. 에러 발생 시 폼 하단에 오류 메시지 출력.
29. Finalize Delete Functionality: 페이지 삭제 기능 마무리. PageDetailPage에서 구현한 deleteMutation이 전체 앱 상태를 잘 갱신하는지 확인합니다.
o PageList (홈)에서 삭제된 페이지가 빠졌는지 확인 (React Query invalidate가 잘 동작하면 자동 갱신될 것). 혹시 캐시 갱신이 실시간으로 안 된다면, 수동으로 상태를 업데이트하거나 PageList에서도 React Query 캐시를 subscribe하여 변경을 감지하는 방안 고려. 하지만 기본적으로 invalidateQueries(['pages']) 호출로 PageListPage의 useQuery가 재실행되어 최신 pages를 가져오게 됩니다.
o 삭제 후 navigate("/")로 간 후, PageDetailPage가 언마운트되며 혹시 있을 수 있는 memory leak 방지 (예: 컴포넌트 언마운트 후 setState 없도록). React Query의 자동 취소 기능이 있으므로 대체로 안전하지만, 필요 시 onSettled에서 추가 처리를 검토.
o Radix AlertDialog 모달이 ESC나 Cancel로 잘 닫히는지 UX 확인.
o 작업 내용: 위 시나리오를 수동 테스트하여 결함이 없는지 점검하고, 필요한 경우 코드 보완.
30. Testing & Polish: 모든 주요 기능을 구현한 뒤, 앱 전반에 걸쳐 QA 테스트를 수행하고 마무리 다듬기를 합니다.
o 기능 테스트: 페이지 생성 → 목록/검색 반영 확인, 페이지 편집 → 상세뷰 반영 확인, 페이지 삭제 → 목록 제거/라우팅 확인, 검색 → 올바른 필터링 작동 여부 등을 각각 시나리오별로 테스트합니다. 엣지 케이스로 빈 제목 생성, 매우 긴 내용 입력, 연속 빠른 조작 등에 앱이 잘 대응하는지 확인합니다.
o 오류 처리: 더미 API 상에서 발생할 수 있는 에러 (예: 중복된 ID, 없는 페이지 접근 등)에 대비하여 사용자에게 안내를 추가합니다. 예를 들어 존재하지 않는 페이지 ID로 /pages/abc 접근 시 PageDetailPage의 useQuery 결과가 undefined이면 "페이지를 찾을 수 없습니다" 메시지와 홈으로 가는 링크를 제공하는 식으로 처리합니다.
o UI 폴리시: 디자인 일관성 점검 – 폰트 크기/색상 통일, 다크모드 미지원 안내 여부, 반응형 동작 확인 (브라우저 크기 줄였을 때 메뉴나 리스트가 깨지지 않는지). 필요하면 CSS 미세 조정.
o 코드 정리: 콘솔 로그 등 디버그 코드를 제거하고, 타입 any 남용된 부분 없애기, 불필요한 주석 정리. 컴포넌트 구조가 FSD 규칙에 어긋나는 부분이 없는지 재확인 (shared 폴더의 역할 남용 여부 등).
o 문서 보완: README나 주석에 사용 방법, 폴더 구조 설명 등을 추가합니다. 동료 개발자가 본 프로젝트를 쉽게 이해할 수 있도록, PRD 주요 내용을 README에 요약하거나, FSD 구조를 그림으로 넣어도 좋습니다.
이상으로 개인 위키 SPA 프로젝트의 요구사항 정의와 구현 계획을 모두 정리했습니다. 위 계획을 차근차근 실행하면, 공식 문서 느낌의 세련된 Wiki 웹앱을 완성할 수 있을 것입니다. 각 작업이 완료될 때마다 애플리케이션이 의도대로 동작하는지 확인하면서 진행합니다. 필요에 따라 조율하며 개발하면 무리 없이 프로젝트 목표를 달성할 수 있을 것입니다.
________________________________________
[1] 쉽게 정리한 Feature-Sliced Design(FSD) 가이드
https://dansoon-dev.tistory.com/13
[2] Welcome | Feature-Sliced Design
https://feature-sliced.design/
[3] [7] React-Query 개념
https://velog.io/@parkcode/React-Query-%EA%B0%9C%EB%85%90
[4] Headless UI vs Radix UI: Which Component Library Is Right for You? - Lodely
https://www.lodely.com/blog/headless-ui-vs-radix-ui
[5] [6] [8] [9] Building components with Radix UI | Refine
https://refine.dev/blog/radix-ui/
+1
View File
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

After

Width:  |  Height:  |  Size: 1.5 KiB

+29
View File
@@ -0,0 +1,29 @@
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { BrowserRouter, Routes, Route } from 'react-router-dom';
import { PageListPage, PageDetailPage, PageEditPage } from '../pages';
const queryClient = new QueryClient({
defaultOptions: {
queries: {
staleTime: 1000 * 60 * 5, // 5 minutes
refetchOnWindowFocus: false,
},
},
});
function App() {
return (
<QueryClientProvider client={queryClient}>
<BrowserRouter>
<Routes>
<Route path="/" element={<PageListPage />} />
<Route path="/pages/new" element={<PageEditPage />} />
<Route path="/pages/:id" element={<PageDetailPage />} />
<Route path="/pages/:id/edit" element={<PageEditPage />} />
</Routes>
</BrowserRouter>
</QueryClientProvider>
);
}
export default App;
+63
View File
@@ -0,0 +1,63 @@
import type { Page, CreatePageData, UpdatePageData } from './types';
import { pages, setPages } from './data';
// Simulated network delay
const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
function generateId(): string {
return 'page-' + Date.now() + '-' + Math.random().toString(36).substr(2, 9);
}
export async function getPages(): Promise<Page[]> {
await delay(200);
return [...pages];
}
export async function getPage(id: string): Promise<Page> {
await delay(150);
const page = pages.find(p => p.id === id);
if (!page) {
throw new Error(`Page with id ${id} not found`);
}
return { ...page };
}
export async function createPage(data: CreatePageData): Promise<Page> {
await delay(300);
const newPage: Page = {
id: generateId(),
title: data.title,
content: data.content,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
};
setPages([...pages, newPage]);
return newPage;
}
export async function updatePage(id: string, data: UpdatePageData): Promise<Page> {
await delay(300);
const pageIndex = pages.findIndex(p => p.id === id);
if (pageIndex === -1) {
throw new Error(`Page with id ${id} not found`);
}
const updatedPage: Page = {
...pages[pageIndex],
title: data.title,
content: data.content,
updatedAt: new Date().toISOString(),
};
const newPages = [...pages];
newPages[pageIndex] = updatedPage;
setPages(newPages);
return updatedPage;
}
export async function deletePage(id: string): Promise<void> {
await delay(200);
const pageExists = pages.some(p => p.id === id);
if (!pageExists) {
throw new Error(`Page with id ${id} not found`);
}
setPages(pages.filter(p => p.id !== id));
}
+160
View File
@@ -0,0 +1,160 @@
import type { Page } from './types';
export let pages: Page[] = [
{
id: 'page-1',
title: '.NET의 새로운 기능',
content: `.NET의 최신 기능과 개선사항을 소개합니다.`,
parentId: null,
order: 1,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
},
{
id: 'page-1-1',
title: '.NET 10',
content: `.NET 10의 주요 기능과 개선사항`,
parentId: 'page-1',
order: 1,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
},
{
id: 'page-1-1-1',
title: '새로운 기능',
content: `.NET 10에 새로운 기능에 대해 알아보고 주요 성능 업데이트를 살펴보십시오. 이 페이지는 RC 2에 대해 업데이트되었습니다.
.NET 9 출시 비전인 .NET 10은 (작성 기준), 범위되는 포커스 영역입니다. 프롬프트 SDK 대화하거나 직접에는 쓰는 텍스트한 없다 앞해보세요.
주요 내용:
- .NET 10 런타임에서는 JIT 컴파일러 및 라이브러리 성능 개선이라이 개선되었습니다. 또한 .NET 컨테이너를 위한 새로운 기능, 구조 API, Serialization 성능 향상 및 다양한 LINQ 새로운 업그레이드.
- .NET 10은 타입레벨에서 사용 방법을 향상시켰으며, 에 검 방지 진, 새로운 문장 우선시를 포함한 추 구기 필요 생성되며 성능을 향상시켰습니다.
- .NET SDK는 .NET 컨테이너를 쉽게 구축할 수 있는 개선사항을 제공합니다.`,
parentId: 'page-1-1',
order: 1,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
},
{
id: 'page-1-1-2',
title: '런타임',
content: `.NET 10 런타임에서는 JIT (Just-In-Time) 컴파일러, 런타임 클라우드 네이티브 지원을 향상시키기 위한 컨테이너 개선 사항, 그리고 구조 라이브러리의 다양한 향상을 포함한 여러 성능 개선이 이루어졌습니다.
JIT 컴파일러 개선
- 향상된 인라이닝 및 최적화
- SIMD(Single Instruction, Multiple Data) 벡터화 개선
- ARM64 아키텍처를 위한 추가 최적화
컨테이너 지원
.NET 10에서는 컨테이너에서 실행되는 애플리케이션에 대한 다음과 같은 개선 사항이 추가되었습니다:
- 더 작은 컨테이너 이미지 크기
- 더 빠른 시작 시간
- 향상된 리소스 사용량 모니터링`,
parentId: 'page-1-1',
order: 2,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
},
{
id: 'page-1-1-3',
title: '라이브러리',
content: `.NET 라이브러리는 Serialization, JSON 처리, LINQ, 그리고 Windows cryptography API 지원 등에서 다양한 개선이 이루어졌습니다.
Serialization 개선사항
- System.Text.Json의 성능이 크게 향상되었습니다
- 새로운 직렬화 옵션 추가
- 커스텀 컨버터 지원 개선
LINQ 향상
.NET 10에는 다음과 같은 새로운 LINQ 메서드가 추가되었습니다:
- CountBy: 요소를 그룹화하고 각 그룹의 개수를 반환
- AggregateBy: 그룹별로 집계 수행
- Index: 요소에 인덱스를 추가
Windows Cryptography
Windows 플랫폼에서 새로운 암호화 기능을 지원합니다.`,
parentId: 'page-1-1',
order: 3,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
},
{
id: 'page-1-1-4',
title: 'SDK',
content: `.NET 10 SDK에는 개발자 경험을 향상시키는 여러 기능이 추가되었습니다.
컨테이너 게시 개선
- 더 쉬운 컨테이너 빌드 및 게시
- 자동화된 태그 지정
- 레지스트리 푸시 최적화
워크로드 업데이트
.NET 워크로드 설치 및 업데이트가 더욱 간소화되었습니다:
- 더 빠른 설치 속도
- 향상된 오프라인 지원
- 더 나은 오류 메시지
성능 분석
새로운 성능 분석 도구가 SDK에 통합되었습니다.`,
parentId: 'page-1-1',
order: 4,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
},
{
id: 'page-2',
title: 'ASP.NET Core',
content: `ASP.NET Core 10에는 Blazor, SignalR, 그리고 최소 API에 대한 많은 개선 사항이 포함되어 있습니다.
Blazor 개선사항
- 향상된 렌더링 성능
- 새로운 컴포넌트 라이프사이클 이벤트
- 개선된 양방향 바인딩
SignalR 업데이트
- 더 나은 확장성
- 향상된 연결 복원력
- 새로운 전송 옵션
최소 API
최소 API 기능이 확장되어 더 복잡한 시나리오를 지원합니다:
- 향상된 라우팅
- 필터 지원
- 더 나은 OpenAPI 통합`,
parentId: null,
order: 2,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
},
{
id: 'page-2-1',
title: 'ASP.NET Core',
content: `ASP.NET Core 10에는 Blazor, SignalR, 그리고 최소 API에 대한 많은 개선 사항이 포함되어 있습니다.
Blazor 개선사항
- 향상된 렌더링 성능
- 새로운 컴포넌트 라이프사이클 이벤트
- 개선된 양방향 바인딩
SignalR 업데이트
- 더 나은 확장성
- 향상된 연결 복원력
- 새로운 전송 옵션
최소 API
최소 API 기능이 확장되어 더 복잡한 시나리오를 지원합니다:
- 향상된 라우팅
- 필터 지원
- 더 나은 OpenAPI 통합`,
parentId: "page-2",
order: 4,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
},
];
export function setPages(newPages: Page[]) {
pages = newPages;
}
+2
View File
@@ -0,0 +1,2 @@
export * from './types';
export * from './api';
+21
View File
@@ -0,0 +1,21 @@
export interface Page {
id: string;
title: string;
content: string;
parentId?: string | null;
order?: number;
createdAt: string;
updatedAt: string;
}
export interface CreatePageData {
title: string;
content: string;
parentId?: string | null;
order?: number;
}
export interface UpdatePageData {
title: string;
content: string;
}
+99
View File
@@ -0,0 +1,99 @@
import { useState } from 'react';
import type { FormEvent } from 'react';
import { LexicalEditor } from '../../shared/LexicalEditor';
interface PageFormData {
title: string;
content: string;
}
interface PageFormProps {
initialData?: PageFormData;
onSubmit: (data: PageFormData) => void;
onCancel: () => void;
isSubmitting: boolean;
isNew: boolean;
}
export function PageForm({
initialData,
onSubmit,
onCancel,
isSubmitting = false,
isNew = false
}: PageFormProps) {
const [title, setTitle] = useState(initialData?.title || '');
const [content, setContent] = useState(initialData?.content || '');
const [error, setError] = useState('');
const handleSubmit = (e: FormEvent) => {
e.preventDefault();
if (!title.trim()) {
setError('제목은 필수입니다.');
return;
}
if (!content.trim()) {
setError('내용은 필수입니다.');
return;
}
setError('');
onSubmit({ title: title.trim(), content: content.trim() });
};
return (
<form onSubmit={handleSubmit} className="space-y-6">
{error && (
<div className="p-4 bg-red-900/20 border border-red-500/50 rounded-lg">
<p className="text-sm text-red-400">{error}</p>
</div>
)}
<div>
<label htmlFor="title" className="block text-sm font-medium text-[#e4e4e4] mb-2">
제목
</label>
<input
type="text"
id="title"
value={title}
onChange={(e) => setTitle(e.target.value)}
className="w-full px-4 py-2.5 bg-[#2d2d30] border border-[#3e3e42] rounded text-[#e4e4e4] placeholder-[#9d9d9d] focus:outline-none focus:border-[#0078d4] focus:ring-1 focus:ring-[#0078d4]"
placeholder="페이지 제목을 입력하세요"
disabled={isSubmitting}
/>
</div>
<div>
<label htmlFor="content" className="block text-sm font-medium text-[#e4e4e4] mb-2">
내용
</label>
<LexicalEditor
initialContent={content}
onChange={setContent}
placeholder="페이지 내용을 입력하세요..."
/>
</div>
<div className="flex gap-3 pt-4">
<button
type="button"
onClick={onCancel}
disabled={isSubmitting}
className="px-6 py-2.5 bg-[#2d2d30] border border-[#3e3e42] rounded text-[#e4e4e4] hover:bg-[#3e3e42] disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
>
취소
</button>
<button
type="submit"
disabled={isSubmitting}
className="px-6 py-2.5 bg-[#0078d4] text-white rounded hover:bg-[#106ebe] disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
>
{isSubmitting ? '저장 중...' : isNew ? '생성' : '저장'}
</button>
</div>
</form>
);
}
+18
View File
@@ -0,0 +1,18 @@
import { Link } from 'react-router-dom';
import type { Page } from '../../entities/page';
interface PageItemProps {
page: Page;
}
export function PageItem({ page }: PageItemProps) {
return (
<Link
to={`/pages/${page.id}`}
className="block p-4 border border-gray-200 rounded-lg hover:border-blue-500 hover:shadow-md transition-all"
>
<h3 className="text-lg font-semibold text-gray-900 mb-2">{page.title}</h3>
<p className="text-sm text-gray-600 line-clamp-2">{page.content}</p>
</Link>
);
}
+24
View File
@@ -0,0 +1,24 @@
import type { Page } from '../../entities/page';
import { PageItem } from './PageItem';
interface PageListProps {
pages: Page[];
}
export function PageList({ pages }: PageListProps) {
if (pages.length === 0) {
return (
<div className="text-center py-12">
<p className="text-gray-500">일치하는 페이지가 없습니다.</p>
</div>
);
}
return (
<div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
{pages.map((page) => (
<PageItem key={page.id} page={page} />
))}
</div>
);
}
+3
View File
@@ -0,0 +1,3 @@
export * from './PageItem';
export * from './PageList';
export * from './PageForm';
+29
View File
@@ -0,0 +1,29 @@
import type { ChangeEvent } from 'react';
import { MagnifyingGlassIcon } from '@radix-ui/react-icons';
interface SearchBarProps {
value: string;
onChange: (value: string) => void;
placeholder?: string;
}
export function SearchBar({ value, onChange, placeholder = '검색어를 입력하세요' }: SearchBarProps) {
const handleChange = (e: ChangeEvent<HTMLInputElement>) => {
onChange(e.target.value);
};
return (
<div className="relative">
<div className="absolute inset-y-0 left-0 pl-3 flex items-center pointer-events-none">
<MagnifyingGlassIcon className="h-5 w-5 text-gray-400" />
</div>
<input
type="text"
value={value}
onChange={handleChange}
className="block w-full pl-10 pr-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
placeholder={placeholder}
/>
</div>
);
}
+1
View File
@@ -0,0 +1 @@
export * from './SearchBar';
+37
View File
@@ -0,0 +1,37 @@
@import "tailwindcss";
@layer base {
:root {
--color-bg-primary: #1e1e1e;
--color-bg-secondary: #252526;
--color-bg-tertiary: #2d2d30;
--color-text-primary: #e4e4e4;
--color-text-secondary: #9d9d9d;
--color-border: #3e3e42;
--color-accent: #0078d4;
--color-accent-hover: #106ebe;
}
body {
@apply min-h-screen bg-[#1e1e1e] text-[#e4e4e4];
font-family: "Noto Sans KR", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
}
/* Lexical 에디터와 뷰어에서 인라인 스타일 허용 */
.lexical-viewer span[style*="font-family"],
[contenteditable="true"] span[style*="font-family"] {
font-family: inherit;
}
* {
@apply border-[#3e3e42];
}
a {
@apply text-[#4db8ff] hover:text-[#8cd7ff] transition-colors;
}
code {
@apply bg-[#2d2d30] px-1 py-0.5 rounded text-sm;
}
}
+10
View File
@@ -0,0 +1,10 @@
import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import './index.css'
import App from './app/App.tsx'
createRoot(document.getElementById('root')!).render(
<StrictMode>
<App />
</StrictMode>,
)
+136
View File
@@ -0,0 +1,136 @@
import { useParams, useNavigate, Link } from 'react-router-dom';
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { getPage, deletePage } from '../entities/page';
import { Breadcrumb } from '../shared/Breadcrumb';
import { RightSidebar } from '../shared/RightSidebar';
import { Layout } from '../shared/Layout';
import { LexicalViewer } from '../shared/LexicalViewer';
import * as AlertDialog from '@radix-ui/react-alert-dialog';
import { Pencil1Icon, TrashIcon } from '@radix-ui/react-icons';
import { useState } from 'react';
function PageDetailContent() {
const { id } = useParams<{ id: string }>();
const navigate = useNavigate();
const queryClient = useQueryClient();
const [showDeleteDialog, setShowDeleteDialog] = useState(false);
const { data: page, isLoading, error } = useQuery({
queryKey: ['page', id],
queryFn: () => getPage(id!),
enabled: !!id,
});
const deleteMutation = useMutation({
mutationFn: () => deletePage(id!),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['pages'] });
queryClient.removeQueries({ queryKey: ['page', id] });
navigate('/');
},
});
const handleDelete = () => {
deleteMutation.mutate();
setShowDeleteDialog(false);
};
if (isLoading) {
return (
<div className="flex justify-center items-center py-12">
<p className="text-[#9d9d9d]">불러오는 중...</p>
</div>
);
}
if (error || !page) {
return (
<div className="flex flex-col items-center justify-center py-12 space-y-4">
<p className="text-red-400">페이지를 찾을 수 없습니다.</p>
<Link to="/" className="text-[#4db8ff] hover:text-[#8cd7ff]">
목록으로 돌아가기
</Link>
</div>
);
}
return (
<>
<Breadcrumb
items={[
{ label: 'Learn', path: '/' },
{ label: page.title },
]}
/>
<article className="max-w-4xl">
{/* Title and Actions */}
<div className="mb-8">
<h1 className="text-4xl font-bold text-[#e4e4e4] mb-4">{page.title}</h1>
<div className="flex gap-3">
<Link
to={`/pages/${id}/edit`}
className="inline-flex items-center gap-2 px-4 py-2 bg-[#2d2d30] border border-[#3e3e42] rounded text-[#e4e4e4] hover:bg-[#3e3e42] transition-colors"
>
<Pencil1Icon className="h-4 w-4" />
편집
</Link>
<AlertDialog.Root open={showDeleteDialog} onOpenChange={setShowDeleteDialog}>
<AlertDialog.Trigger asChild>
<button className="inline-flex items-center gap-2 px-4 py-2 bg-[#2d2d30] border border-[#3e3e42] rounded text-red-400 hover:bg-[#3e3e42] transition-colors">
<TrashIcon className="h-4 w-4" />
삭제
</button>
</AlertDialog.Trigger>
<AlertDialog.Portal>
<AlertDialog.Overlay className="fixed inset-0 bg-black/70 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0" />
<AlertDialog.Content className="fixed left-1/2 top-1/2 max-w-md -translate-x-1/2 -translate-y-1/2 rounded-lg bg-[#252526] border border-[#3e3e42] p-6 shadow-xl data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95">
<AlertDialog.Title className="text-lg font-semibold text-[#e4e4e4] mb-2">
페이지 삭제
</AlertDialog.Title>
<AlertDialog.Description className="text-sm text-[#9d9d9d] mb-6">
정말 이 페이지를 삭제하시겠습니까? 이 동작은 되돌릴 수 없습니다.
</AlertDialog.Description>
<div className="flex gap-3 justify-end">
<AlertDialog.Cancel asChild>
<button className="px-4 py-2 bg-[#2d2d30] border border-[#3e3e42] rounded text-[#e4e4e4] hover:bg-[#3e3e42]">
취소
</button>
</AlertDialog.Cancel>
<AlertDialog.Action asChild>
<button
onClick={handleDelete}
disabled={deleteMutation.isPending}
className="px-4 py-2 bg-red-600 text-white rounded hover:bg-red-700 disabled:opacity-50"
>
{deleteMutation.isPending ? '삭제 중...' : '삭제'}
</button>
</AlertDialog.Action>
</div>
</AlertDialog.Content>
</AlertDialog.Portal>
</AlertDialog.Root>
</div>
</div>
{/* Content */}
<LexicalViewer content={page.content} />
{/* Metadata */}
{page.updatedAt && (
<div className="mt-8 pt-4 border-t border-[#3e3e42] text-sm text-[#9d9d9d]">
마지막 업데이트: {new Date(page.updatedAt).toLocaleString('ko-KR')}
</div>
)}
</article>
</>
);
}
export function PageDetailPage() {
return (
<Layout rightSidebar={<RightSidebar />}>
<PageDetailContent />
</Layout>
);
}
+85
View File
@@ -0,0 +1,85 @@
import { useParams, useNavigate } from 'react-router-dom';
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { getPage, createPage, updatePage } from '../entities/page';
import { PageForm } from '../features/page';
import { Layout } from '../shared/Layout';
import { Breadcrumb } from '../shared/Breadcrumb';
export function PageEditPage() {
const { id } = useParams<{ id: string }>();
const navigate = useNavigate();
const queryClient = useQueryClient();
const isNew = !id;
const { data: page, isLoading } = useQuery({
queryKey: ['page', id],
queryFn: () => getPage(id!),
enabled: !isNew,
});
const createMutation = useMutation({
mutationFn: createPage,
onSuccess: (newPage) => {
queryClient.invalidateQueries({ queryKey: ['pages'] });
navigate(`/pages/${newPage.id}`);
},
});
const updateMutation = useMutation({
mutationFn: (data: { title: string; content: string }) =>
updatePage(id!, data),
onSuccess: (updatedPage) => {
queryClient.setQueryData(['page', id], updatedPage);
queryClient.invalidateQueries({ queryKey: ['pages'] });
navigate(`/pages/${id}`);
},
});
const handleSubmit = (data: { title: string; content: string }) => {
if (isNew) {
createMutation.mutate(data);
} else {
updateMutation.mutate(data);
}
};
const handleCancel = () => {
navigate(-1);
};
if (!isNew && isLoading) {
return (
<Layout>
<div className="flex justify-center items-center py-12">
<p className="text-[#9d9d9d]">불러오는 중...</p>
</div>
</Layout>
);
}
const isSubmitting = createMutation.isPending || updateMutation.isPending;
return (
<Layout>
<Breadcrumb
items={[
{ label: 'Learn', path: '/' },
{ label: isNew ? '새 페이지 만들기' : page?.title || '편집' },
]}
/>
<div className="max-w-4xl">
<h1 className="text-4xl font-bold text-[#e4e4e4] mb-8">
{isNew ? '새 페이지 만들기' : '페이지 편집'}
</h1>
<PageForm
initialData={page}
onSubmit={handleSubmit}
onCancel={handleCancel}
isSubmitting={isSubmitting}
isNew={isNew}
/>
</div>
</Layout>
);
}
+80
View File
@@ -0,0 +1,80 @@
import { useQuery } from '@tanstack/react-query';
import { Link } from 'react-router-dom';
import { getPages } from '../entities/page';
import { Layout } from '../shared/Layout';
import { Breadcrumb } from '../shared/Breadcrumb';
import { FileTextIcon } from '@radix-ui/react-icons';
export function PageListPage() {
const { data: pages = [], isLoading, error } = useQuery({
queryKey: ['pages'],
queryFn: getPages,
});
if (isLoading) {
return (
<Layout showSidebar={false}>
<div className="flex justify-center items-center py-12">
<p className="text-[#9d9d9d]">불러오는 중...</p>
</div>
</Layout>
);
}
if (error) {
return (
<Layout showSidebar={false}>
<div className="flex justify-center items-center py-12">
<p className="text-red-400">오류가 발생했습니다: {(error as Error).message}</p>
</div>
</Layout>
);
}
return (
<Layout showSidebar={false}>
<Breadcrumb items={[{ label: 'Learn' }]} />
<div className="max-w-5xl">
<h1 className="text-4xl font-bold text-[#e4e4e4] mb-2">위키 페이지</h1>
<p className="text-[#9d9d9d] mb-8">
모든 문서를 찾아보세요. 왼쪽 사이드바에서 검색하거나 아래 목록을 탐색할 수 있습니다.
</p>
<div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
{pages.map((page) => (
<Link
key={page.id}
to={`/pages/${page.id}`}
className="block p-5 bg-[#252526] border border-[#3e3e42] rounded-lg hover:border-[#0078d4] hover:shadow-lg transition-all"
>
<div className="flex items-start gap-3">
<FileTextIcon className="h-5 w-5 text-[#0078d4] flex-shrink-0 mt-1" />
<div className="flex-1 min-w-0">
<h3 className="text-lg font-semibold text-[#e4e4e4] mb-2 truncate">
{page.title}
</h3>
<p className="text-sm text-[#9d9d9d] line-clamp-3">
{page.content}
</p>
</div>
</div>
</Link>
))}
</div>
{pages.length === 0 && (
<div className="text-center py-12">
<p className="text-[#9d9d9d] mb-4">아직 페이지가 없습니다.</p>
<Link
to="/pages/new"
className="inline-flex items-center gap-2 px-4 py-2 bg-[#0078d4] hover:bg-[#106ebe] text-white rounded transition-colors"
>
첫 페이지 만들기
</Link>
</div>
)}
</div>
</Layout>
);
}
+3
View File
@@ -0,0 +1,3 @@
export * from './PageListPage';
export * from './PageDetailPage';
export * from './PageEditPage';
+30
View File
@@ -0,0 +1,30 @@
import { Link } from 'react-router-dom';
import { ChevronRightIcon } from '@radix-ui/react-icons';
interface BreadcrumbItem {
label: string;
path?: string;
}
interface BreadcrumbProps {
items: BreadcrumbItem[];
}
export function Breadcrumb({ items }: BreadcrumbProps) {
return (
<nav className="flex items-center space-x-2 text-sm text-[#9d9d9d] mb-6">
{items.map((item, index) => (
<div key={index} className="flex items-center">
{index > 0 && <ChevronRightIcon className="h-4 w-4 mx-2" />}
{item.path ? (
<Link to={item.path} className="hover:text-[#e4e4e4] transition-colors">
{item.label}
</Link>
) : (
<span className="text-[#e4e4e4]">{item.label}</span>
)}
</div>
))}
</nav>
);
}
+48
View File
@@ -0,0 +1,48 @@
import type { ReactNode } from 'react';
import { Link } from 'react-router-dom';
import { LeftSidebar } from './LeftSidebar';
interface LayoutProps {
children: ReactNode;
showSidebar?: boolean;
rightSidebar?: ReactNode;
}
export function Layout({ children, showSidebar = true, rightSidebar }: LayoutProps) {
return (
<div className="min-h-screen bg-[#1e1e1e]">
{/* Left Sidebar - fixed positioning */}
{showSidebar && <LeftSidebar />}
{/* Main Content */}
<div className={`flex-1 flex flex-col min-w-0 ${showSidebar ? 'ml-64' : ''}`}>
{/* Top Header */}
<header className="bg-[#252526] border-b border-[#3e3e42] sticky top-0 z-10">
<div className="px-6 py-3 flex items-center justify-between">
<Link to="/" className="text-xl font-semibold text-[#e4e4e4] hover:text-[#4db8ff] transition-colors">
Gem Wiki (잼위키)
</Link>
<nav className="flex items-center gap-6 text-sm">
<Link to="/" className="text-[#9d9d9d] hover:text-[#e4e4e4] transition-colors">
Learn
</Link>
<Link to="/pages/new" className="px-4 py-1.5 bg-[#0078d4] hover:bg-[#106ebe] text-white rounded transition-colors">
새 페이지
</Link>
</nav>
</div>
</header>
{/* Content Area */}
<div className="flex flex-1">
<main className={`flex-1 px-8 py-6 overflow-y-auto ${rightSidebar ? 'mr-64' : ''}`}>
{children}
</main>
{/* Right Sidebar - fixed positioning handled in component */}
{rightSidebar}
</div>
</div>
</div>
);
}
+137
View File
@@ -0,0 +1,137 @@
import { useState } from 'react';
import { Link, useLocation } from 'react-router-dom';
import { useQuery } from '@tanstack/react-query';
import { getPages, type Page } from '../entities/page';
import { MagnifyingGlassIcon, FileTextIcon, PlusIcon, ChevronRightIcon, ChevronDownIcon } from '@radix-ui/react-icons';
interface TreeNodeProps {
page: Page;
children: Page[];
allPages: Page[];
searchQuery: string;
level: number;
}
function TreeNode({ page, children, allPages, searchQuery, level }: TreeNodeProps) {
const location = useLocation();
const [isExpanded, setIsExpanded] = useState(true);
const isActive = location.pathname === `/pages/${page.id}`;
const hasChildren = children.length > 0;
const matchesSearch = searchQuery === '' || page.title.toLowerCase().includes(searchQuery.toLowerCase());
if (!matchesSearch && searchQuery !== '') {
return null;
}
return (
<div>
<div className="flex items-center">
{hasChildren && (
<button
onClick={() => setIsExpanded(!isExpanded)}
className="p-1 hover:bg-[#2d2d30] rounded transition-colors flex-shrink-0"
>
{isExpanded ? (
<ChevronDownIcon className="h-3 w-3 text-[#9d9d9d]" />
) : (
<ChevronRightIcon className="h-3 w-3 text-[#9d9d9d]" />
)}
</button>
)}
{!hasChildren && <div className="w-5" />}
<Link
to={`/pages/${page.id}`}
className={`flex-1 flex items-center gap-2 px-2 py-1.5 text-sm rounded transition-colors ${
isActive
? 'bg-[#0078d4] text-white'
: 'text-[#e4e4e4] hover:bg-[#2d2d30]'
}`}
style={{ paddingLeft: `${level * 12 + 8}px` }}
>
<FileTextIcon className="h-3.5 w-3.5 flex-shrink-0" />
<span className="truncate">{page.title}</span>
</Link>
</div>
{hasChildren && isExpanded && (
<div>
{children.map(child => {
const grandChildren = allPages.filter(p => p.parentId === child.id);
return (
<TreeNode
key={child.id}
page={child}
children={grandChildren}
allPages={allPages}
searchQuery={searchQuery}
level={level + 1}
/>
);
})}
</div>
)}
</div>
);
}
export function LeftSidebar() {
const [searchQuery, setSearchQuery] = useState('');
const { data: pages = [] } = useQuery({
queryKey: ['pages'],
queryFn: getPages,
});
// Build tree structure
const rootPages = pages.filter(page => !page.parentId).sort((a, b) => (a.order || 0) - (b.order || 0));
return (
<aside className="w-64 h-screen fixed left-0 top-0 bg-[#252526] border-r border-[#3e3e42] flex flex-col overflow-hidden z-20">
{/* Search Box */}
<div className="p-4 border-b border-[#3e3e42]">
<div className="relative">
<MagnifyingGlassIcon className="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-[#9d9d9d]" />
<input
type="text"
value={searchQuery}
onChange={(e) => setSearchQuery(e.target.value)}
placeholder="Find by title"
className="w-full pl-9 pr-3 py-2 bg-[#2d2d30] border border-[#3e3e42] rounded text-sm text-[#e4e4e4] placeholder-[#9d9d9d] focus:outline-none focus:border-[#0078d4]"
/>
</div>
</div>
{/* Navigation */}
<div className="flex-1 overflow-y-auto">
<nav className="p-2">
<div className="mb-2">
<Link
to="/pages/new"
className="flex items-center gap-2 px-3 py-2 text-sm rounded hover:bg-[#2d2d30] text-[#4db8ff] transition-colors"
>
<PlusIcon className="h-4 w-4" />
새 페이지 만들기
</Link>
</div>
<div className="space-y-0.5">
{rootPages.map(page => {
const children = pages.filter(p => p.parentId === page.id).sort((a, b) => (a.order || 0) - (b.order || 0));
return (
<TreeNode
key={page.id}
page={page}
children={children}
allPages={pages}
searchQuery={searchQuery}
level={0}
/>
);
})}
</div>
</nav>
</div>
</aside>
);
}
+724
View File
@@ -0,0 +1,724 @@
import { useEffect, useRef, useState } from 'react';
import { LexicalComposer } from '@lexical/react/LexicalComposer';
import { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin';
import { ContentEditable } from '@lexical/react/LexicalContentEditable';
import { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin';
import { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin';
import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
import { LexicalErrorBoundary } from '@lexical/react/LexicalErrorBoundary';
import { ListPlugin } from '@lexical/react/LexicalListPlugin';
import { LinkPlugin } from '@lexical/react/LexicalLinkPlugin';
import { HeadingNode, QuoteNode } from '@lexical/rich-text';
import { ListNode, ListItemNode } from '@lexical/list';
import { CodeNode, CodeHighlightNode } from '@lexical/code';
import { LinkNode, AutoLinkNode } from '@lexical/link';
import { TableNode, TableCellNode, TableRowNode } from '@lexical/table';
import { TablePlugin } from '@lexical/react/LexicalTablePlugin';
import type { EditorState } from 'lexical';
import { $getRoot, $createParagraphNode, $createTextNode, FORMAT_TEXT_COMMAND, FORMAT_ELEMENT_COMMAND, $getSelection, $isRangeSelection, TextNode } from 'lexical';
import { INSERT_TABLE_COMMAND } from '@lexical/table';
import { $createHeadingNode } from '@lexical/rich-text';
import { INSERT_UNORDERED_LIST_COMMAND, INSERT_ORDERED_LIST_COMMAND } from '@lexical/list';
import { $createCodeNode } from '@lexical/code';
import { $setBlocksType } from '@lexical/selection';
const editorTheme = {
paragraph: 'mb-2 text-[#e4e4e4]',
heading: {
h1: 'text-3xl font-bold mb-4 text-[#e4e4e4] scroll-mt-20',
h2: 'text-2xl font-bold mb-3 text-[#e4e4e4] scroll-mt-20',
h3: 'text-xl font-semibold mb-2 text-[#e4e4e4] scroll-mt-20',
},
list: {
ul: 'list-disc list-inside mb-2 text-[#e4e4e4]',
ol: 'list-decimal list-inside mb-2 text-[#e4e4e4]',
listitem: 'ml-4',
},
text: {
bold: 'font-bold',
italic: 'italic',
underline: 'underline',
code: 'bg-[#1e1e1e] px-1.5 py-0.5 rounded font-mono text-sm text-[#4db8ff]',
},
code: 'bg-[#1e1e1e] p-4 rounded font-mono text-sm text-[#e4e4e4] mb-2 block overflow-x-auto',
link: 'text-[#4db8ff] hover:text-[#8cd7ff] underline cursor-pointer',
table: 'border-collapse table-auto w-full my-4',
tableCell: 'border border-[#3e3e42] px-3 py-2 text-[#e4e4e4] min-w-[100px]',
tableCellHeader: 'border border-[#3e3e42] px-3 py-2 text-[#e4e4e4] font-bold bg-[#2d2d30]',
};
interface LexicalEditorProps {
initialContent?: string;
onChange: (content: string) => void;
placeholder?: string;
}
const FONT_FAMILIES = [
{ name: 'Noto Sans KR', value: '"Noto Sans KR", sans-serif' },
{ name: 'Noto Serif KR', value: '"Noto Serif KR", serif' },
{ name: 'Gothic A1', value: '"Gothic A1", sans-serif' },
{ name: 'Gowun Batang', value: '"Gowun Batang", serif' },
{ name: 'Gowun Dodum', value: '"Gowun Dodum", sans-serif' },
{ name: 'Asta Sans', value: '"Asta Sans", sans-serif' },
{ name: 'Chiron GoRound TC', value: '"Chiron GoRound TC", sans-serif' },
];
const FONT_SIZES = [
{ name: '10px', value: '10px' },
{ name: '12px', value: '12px' },
{ name: '14px', value: '14px' },
{ name: '16px', value: '16px' },
{ name: '18px', value: '18px' },
{ name: '20px', value: '20px' },
{ name: '24px', value: '24px' },
{ name: '28px', value: '28px' },
{ name: '32px', value: '32px' },
{ name: '36px', value: '36px' },
{ name: '48px', value: '48px' },
];
function OnChangePluginWrapper({ onChange }: { onChange: (content: string) => void }) {
const handleChange = (editorState: EditorState) => {
// Serialize the entire editor state as JSON to preserve formatting
const json = JSON.stringify(editorState.toJSON());
onChange(json);
};
return <OnChangePlugin onChange={handleChange} />;
}
function InitialContentPlugin({ content }: { content?: string }) {
const [editor] = useLexicalComposerContext();
const isInitialized = useRef(false);
useEffect(() => {
// Only set initial content once, on mount
if (content && !isInitialized.current) {
isInitialized.current = true;
try {
// Try to parse as JSON first (new format)
const editorState = editor.parseEditorState(content);
editor.setEditorState(editorState);
} catch {
// Fallback to plain text (legacy format)
editor.update(() => {
const root = $getRoot();
root.clear();
const lines = content.split('\n');
lines.forEach((line) => {
const paragraph = $createParagraphNode();
const text = $createTextNode(line);
paragraph.append(text);
root.append(paragraph);
});
});
}
}
}, [editor, content]);
return null;
}
function AutoFocusPlugin() {
const [editor] = useLexicalComposerContext();
useEffect(() => {
editor.focus();
}, [editor]);
return null;
}
function HeadingIdPlugin() {
const [editor] = useLexicalComposerContext();
useEffect(() => {
// Add data attribute and ID to heading elements for TOC
const updateHeadings = () => {
const headings = document.querySelectorAll('h1, h2, h3');
headings.forEach((heading, index) => {
if (heading instanceof HTMLElement) {
if (!heading.hasAttribute('data-lexical-heading')) {
heading.setAttribute('data-lexical-heading', 'true');
}
if (!heading.id) {
const text = heading.textContent || '';
heading.id = `heading-${index}-${text.toLowerCase().replace(/\s+/g, '-').slice(0, 30)}`;
}
}
});
};
// Initial update
updateHeadings();
// Also register mutation listener
const unregister = editor.registerMutationListener(HeadingNode, () => {
setTimeout(updateHeadings, 50);
});
// Update periodically as backup
const interval = setInterval(updateHeadings, 1000);
return () => {
unregister();
clearInterval(interval);
};
}, [editor]);
return null;
}
interface ToolbarPluginProps {
fontFamily: string;
setFontFamily: (font: string) => void;
fontSize: string;
setFontSize: (size: string) => void;
}
function ToolbarPlugin({ fontFamily, setFontFamily, fontSize, setFontSize }: ToolbarPluginProps) {
const [editor] = useLexicalComposerContext();
const [showTablePicker, setShowTablePicker] = useState(false);
const [tableSize, setTableSize] = useState({ rows: 0, cols: 0 });
const handleFontChange = (e: React.ChangeEvent<HTMLSelectElement>) => {
const newFont = e.target.value;
setFontFamily(newFont);
// Apply font to selected text only
editor.update(() => {
const selection = $getSelection();
if ($isRangeSelection(selection)) {
// Check if there's actually a selection
if (selection.isCollapsed()) {
return;
}
const nodes = selection.getNodes();
if (nodes.length === 0) {
return;
}
const anchor = selection.anchor;
const focus = selection.focus;
const [start, end] = anchor.isBefore(focus) ? [anchor, focus] : [focus, anchor];
nodes.forEach((node, idx) => {
if (node instanceof TextNode) {
const isFirst = idx === 0;
const isLast = idx === nodes.length - 1;
const isOnlyNode = nodes.length === 1;
let startOffset = 0;
let endOffset = node.getTextContentSize();
// Determine start offset for the first node
if (isFirst && start.getNode() === node) {
startOffset = start.offset;
}
// Determine end offset for the last node
if (isLast && end.getNode() === node) {
endOffset = end.offset;
}
// Skip if no actual text is selected in this node
if (startOffset >= endOffset) {
return;
}
// Handle the text splitting
if (isOnlyNode || (isFirst && isLast)) {
// Single node selection
if (startOffset === 0 && endOffset === node.getTextContentSize()) {
// Entire node is selected
applyFontToNode(node, newFont);
} else if (startOffset === 0) {
// Selection starts at beginning
const [leftNode] = node.splitText(endOffset);
applyFontToNode(leftNode, newFont);
} else if (endOffset === node.getTextContentSize()) {
// Selection ends at end
const [, rightNode] = node.splitText(startOffset);
applyFontToNode(rightNode, newFont);
} else {
// Selection is in the middle
const [, middleNode] = node.splitText(startOffset);
const [selectedNode] = middleNode.splitText(endOffset - startOffset);
applyFontToNode(selectedNode, newFont);
}
} else if (isFirst) {
// First node of multi-node selection
if (startOffset === 0) {
applyFontToNode(node, newFont);
} else {
const [, rightNode] = node.splitText(startOffset);
applyFontToNode(rightNode, newFont);
}
} else if (isLast) {
// Last node of multi-node selection
if (endOffset === node.getTextContentSize()) {
applyFontToNode(node, newFont);
} else {
const [leftNode] = node.splitText(endOffset);
applyFontToNode(leftNode, newFont);
}
} else {
// Middle nodes are fully selected
applyFontToNode(node, newFont);
}
}
});
}
});
};
const applyFontToNode = (node: TextNode, fontFamily: string) => {
applyStyleToNode(node, 'font-family', fontFamily);
};
const applyStyleToNode = (node: TextNode, property: string, value: string) => {
const currentStyle = node.getStyle();
const regex = new RegExp(`${property}:[^;]+;?`, 'g');
const styleWithoutProperty = currentStyle.replace(regex, '').trim();
const newStyle = styleWithoutProperty
? `${styleWithoutProperty}; ${property}: ${value}`
: `${property}: ${value}`;
node.setStyle(newStyle);
};
const handleFontSizeChange = (e: React.ChangeEvent<HTMLSelectElement>) => {
const newSize = e.target.value;
setFontSize(newSize);
applyFontSizeToSelection(newSize);
};
const increaseFontSize = () => {
const currentIdx = FONT_SIZES.findIndex(f => f.value === fontSize);
const nextIdx = Math.min(currentIdx + 1, FONT_SIZES.length - 1);
const newSize = FONT_SIZES[nextIdx].value;
setFontSize(newSize);
applyFontSizeToSelection(newSize);
};
const decreaseFontSize = () => {
const currentIdx = FONT_SIZES.findIndex(f => f.value === fontSize);
const prevIdx = Math.max(currentIdx - 1, 0);
const newSize = FONT_SIZES[prevIdx].value;
setFontSize(newSize);
applyFontSizeToSelection(newSize);
};
const applyFontSizeToSelection = (size: string) => {
editor.update(() => {
const selection = $getSelection();
if ($isRangeSelection(selection)) {
if (selection.isCollapsed()) {
return;
}
const nodes = selection.getNodes();
if (nodes.length === 0) {
return;
}
const anchor = selection.anchor;
const focus = selection.focus;
const [start, end] = anchor.isBefore(focus) ? [anchor, focus] : [focus, anchor];
nodes.forEach((node, idx) => {
if (node instanceof TextNode) {
const isFirst = idx === 0;
const isLast = idx === nodes.length - 1;
const isOnlyNode = nodes.length === 1;
let startOffset = 0;
let endOffset = node.getTextContentSize();
if (isFirst && start.getNode() === node) {
startOffset = start.offset;
}
if (isLast && end.getNode() === node) {
endOffset = end.offset;
}
if (startOffset >= endOffset) {
return;
}
if (isOnlyNode || (isFirst && isLast)) {
if (startOffset === 0 && endOffset === node.getTextContentSize()) {
applyStyleToNode(node, 'font-size', size);
} else if (startOffset === 0) {
const [leftNode] = node.splitText(endOffset);
applyStyleToNode(leftNode, 'font-size', size);
} else if (endOffset === node.getTextContentSize()) {
const [, rightNode] = node.splitText(startOffset);
applyStyleToNode(rightNode, 'font-size', size);
} else {
const [, middleNode] = node.splitText(startOffset);
const [selectedNode] = middleNode.splitText(endOffset - startOffset);
applyStyleToNode(selectedNode, 'font-size', size);
}
} else if (isFirst) {
if (startOffset === 0) {
applyStyleToNode(node, 'font-size', size);
} else {
const [, rightNode] = node.splitText(startOffset);
applyStyleToNode(rightNode, 'font-size', size);
}
} else if (isLast) {
if (endOffset === node.getTextContentSize()) {
applyStyleToNode(node, 'font-size', size);
} else {
const [leftNode] = node.splitText(endOffset);
applyStyleToNode(leftNode, 'font-size', size);
}
} else {
applyStyleToNode(node, 'font-size', size);
}
}
});
}
});
};
const formatBold = () => {
editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'bold');
};
const formatItalic = () => {
editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'italic');
};
const formatUnderline = () => {
editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'underline');
};
const formatCode = () => {
editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'code');
};
const insertHeading = (level: 'h1' | 'h2' | 'h3') => {
editor.update(() => {
const selection = $getSelection();
if ($isRangeSelection(selection)) {
$setBlocksType(selection, () => $createHeadingNode(level));
}
});
};
const insertBulletList = () => {
editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined);
};
const insertNumberedList = () => {
editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, undefined);
};
const insertCodeBlock = () => {
editor.update(() => {
const selection = $getSelection();
if ($isRangeSelection(selection)) {
$setBlocksType(selection, () => $createCodeNode());
}
});
};
const formatAlignLeft = () => {
editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'left');
};
const formatAlignCenter = () => {
editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'center');
};
const formatAlignRight = () => {
editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'right');
};
const insertTable = (rows: number, cols: number) => {
editor.dispatchCommand(INSERT_TABLE_COMMAND, { rows: String(rows), columns: String(cols) });
setShowTablePicker(false);
setTableSize({ rows: 0, cols: 0 });
};
return (
<div className="flex flex-wrap gap-1 p-2 bg-[#252526] border border-[#3e3e42] rounded-t mb-[-1px] relative z-10">
{/* Font Family */}
<select
value={fontFamily}
onChange={handleFontChange}
className="px-3 py-1.5 text-sm bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors border border-[#3e3e42] focus:outline-none focus:border-[#0078d4] cursor-pointer"
title="텍스트를 선택한 후 글꼴을 변경하세요"
>
{FONT_FAMILIES.map((font) => (
<option key={font.value} value={font.value} style={{ fontFamily: font.value }}>
{font.name}
</option>
))}
</select>
{/* Font Size */}
<select
value={fontSize}
onChange={handleFontSizeChange}
className="w-20 px-2 py-1.5 text-sm bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors border border-[#3e3e42] focus:outline-none focus:border-[#0078d4] cursor-pointer"
title="텍스트를 선택한 후 크기를 변경하세요"
>
{FONT_SIZES.map((size) => (
<option key={size.value} value={size.value}>
{size.name}
</option>
))}
</select>
<button
onClick={decreaseFontSize}
className="px-2 py-1.5 text-sm bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="글씨 크기 감소"
type="button"
>
가-
</button>
<button
onClick={increaseFontSize}
className="px-2 py-1.5 text-sm bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="글씨 크기 증가"
type="button"
>
가+
</button>
<div className="w-px h-6 bg-[#3e3e42] mx-1 self-center"></div>
{/* Text Formatting */}
<button
onClick={formatBold}
className="px-3 py-1.5 text-sm font-bold bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="Bold (Ctrl+B)"
type="button"
>
B
</button>
<button
onClick={formatItalic}
className="px-3 py-1.5 text-sm italic bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="Italic (Ctrl+I)"
type="button"
>
I
</button>
<button
onClick={formatUnderline}
className="px-3 py-1.5 text-sm underline bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="Underline (Ctrl+U)"
type="button"
>
U
</button>
<button
onClick={formatCode}
className="px-3 py-1.5 text-sm font-mono bg-[#2d2d30] hover:bg-[#3e3e42] text-[#4db8ff] rounded transition-colors"
title="Inline Code"
type="button"
>
&lt;/&gt;
</button>
<div className="w-px h-6 bg-[#3e3e42] mx-1 self-center"></div>
{/* Headings */}
<button
onClick={() => insertHeading('h1')}
className="px-3 py-1.5 text-sm font-bold bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="Heading 1"
type="button"
>
H1
</button>
<button
onClick={() => insertHeading('h2')}
className="px-3 py-1.5 text-sm font-bold bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="Heading 2"
type="button"
>
H2
</button>
<button
onClick={() => insertHeading('h3')}
className="px-3 py-1.5 text-sm font-semibold bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="Heading 3"
type="button"
>
H3
</button>
<div className="w-px h-6 bg-[#3e3e42] mx-1 self-center"></div>
{/* Lists */}
<button
onClick={insertBulletList}
className="px-3 py-1.5 text-sm bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="Bullet List"
type="button"
>
• List
</button>
<button
onClick={insertNumberedList}
className="px-3 py-1.5 text-sm bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="Numbered List"
type="button"
>
1. List
</button>
<button
onClick={insertCodeBlock}
className="px-3 py-1.5 text-sm font-mono bg-[#2d2d30] hover:bg-[#3e3e42] text-[#4db8ff] rounded transition-colors"
title="Code Block"
type="button"
>
{'{ }'}
</button>
<div className="w-px h-6 bg-[#3e3e42] mx-1 self-center"></div>
{/* Table */}
<div className="relative">
<button
onClick={() => setShowTablePicker(!showTablePicker)}
className="px-3 py-1.5 text-sm bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="표 삽입"
type="button"
>
⊞
</button>
{showTablePicker && (
<div className="absolute top-full left-0 mt-1 p-2 bg-[#252526] border border-[#3e3e42] rounded shadow-lg z-20">
<div className="text-xs text-[#9d9d9d] mb-2 text-center">
{tableSize.rows > 0 && tableSize.cols > 0
? `${tableSize.rows} x ${tableSize.cols} 표 삽입`
: '표 삽입'}
</div>
<div className="grid gap-0.5">
{Array.from({ length: 8 }, (_, row) => (
<div key={row} className="flex gap-0.5">
{Array.from({ length: 10 }, (_, col) => (
<div
key={col}
className={`w-5 h-5 border border-[#3e3e42] cursor-pointer transition-colors ${
row < tableSize.rows && col < tableSize.cols
? 'bg-[#0078d4]'
: 'bg-[#2d2d30] hover:bg-[#3e3e42]'
}`}
onMouseEnter={() => setTableSize({ rows: row + 1, cols: col + 1 })}
onClick={() => insertTable(row + 1, col + 1)}
/>
))}
</div>
))}
</div>
</div>
)}
</div>
<div className="w-px h-6 bg-[#3e3e42] mx-1 self-center"></div>
{/* Alignment */}
<button
onClick={formatAlignLeft}
className="px-3 py-1.5 text-sm bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="Align Left"
type="button"
>
≡
</button>
<button
onClick={formatAlignCenter}
className="px-3 py-1.5 text-sm bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="Align Center"
type="button"
>
≣
</button>
<button
onClick={formatAlignRight}
className="px-3 py-1.5 text-sm bg-[#2d2d30] hover:bg-[#3e3e42] text-[#e4e4e4] rounded transition-colors"
title="Align Right"
type="button"
>
≡
</button>
</div>
);
}
function onError(error: Error) {
console.error('Lexical Error:', error);
}
export function LexicalEditor({ initialContent, onChange, placeholder = '내용을 입력하세요...' }: LexicalEditorProps) {
const [fontFamily, setFontFamily] = useState(FONT_FAMILIES[0].value);
const [fontSize, setFontSize] = useState(FONT_SIZES[3].value); // Default: 16px
const initialConfig = {
namespace: 'WikiEditor',
theme: editorTheme,
onError,
nodes: [
HeadingNode,
ListNode,
ListItemNode,
QuoteNode,
CodeNode,
CodeHighlightNode,
LinkNode,
AutoLinkNode,
TableNode,
TableCellNode,
TableRowNode,
],
};
return (
<div className="relative">
<LexicalComposer initialConfig={initialConfig}>
<div className="relative">
<ToolbarPlugin
fontFamily={fontFamily}
setFontFamily={setFontFamily}
fontSize={fontSize}
setFontSize={setFontSize}
/>
<RichTextPlugin
contentEditable={
<ContentEditable
className="min-h-[400px] w-full px-4 py-2.5 bg-[#2d2d30] border border-[#3e3e42] rounded rounded-t-none text-[#e4e4e4] focus:outline-none focus:border-[#0078d4] focus:ring-1 focus:ring-[#0078d4] text-sm overflow-y-auto"
/>
}
placeholder={
<div className="absolute top-2.5 left-4 text-[#9d9d9d] pointer-events-none text-sm">
{placeholder}
</div>
}
ErrorBoundary={LexicalErrorBoundary}
/>
<HistoryPlugin />
<ListPlugin />
<LinkPlugin />
<TablePlugin />
<OnChangePluginWrapper onChange={onChange} />
<InitialContentPlugin content={initialContent} />
<HeadingIdPlugin />
<AutoFocusPlugin />
</div>
</LexicalComposer>
</div>
);
}
+159
View File
@@ -0,0 +1,159 @@
import { useEffect } from 'react';
import { LexicalComposer } from '@lexical/react/LexicalComposer';
import { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin';
import { ContentEditable } from '@lexical/react/LexicalContentEditable';
import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
import { LexicalErrorBoundary } from '@lexical/react/LexicalErrorBoundary';
import { HeadingNode, QuoteNode } from '@lexical/rich-text';
import { ListNode, ListItemNode } from '@lexical/list';
import { CodeNode, CodeHighlightNode } from '@lexical/code';
import { LinkNode, AutoLinkNode } from '@lexical/link';
import { TableNode, TableCellNode, TableRowNode } from '@lexical/table';
import { $getRoot, $createParagraphNode, $createTextNode } from 'lexical';
const viewerTheme = {
paragraph: 'mb-4 leading-relaxed text-[#e4e4e4]',
heading: {
h1: 'text-3xl font-bold mb-4 mt-6 text-[#e4e4e4] scroll-mt-20',
h2: 'text-2xl font-bold mb-3 mt-5 text-[#e4e4e4] scroll-mt-20',
h3: 'text-xl font-semibold mb-2 mt-4 text-[#e4e4e4] scroll-mt-20',
},
list: {
ul: 'list-disc ml-6 mb-4 text-[#e4e4e4]',
ol: 'list-decimal ml-6 mb-4 text-[#e4e4e4]',
listitem: 'mb-1',
},
text: {
bold: 'font-bold',
italic: 'italic',
underline: 'underline',
code: 'bg-[#1e1e1e] px-1.5 py-0.5 rounded font-mono text-sm text-[#4db8ff]',
},
code: 'bg-[#1e1e1e] p-4 rounded font-mono text-sm text-[#e4e4e4] mb-4 block overflow-x-auto',
link: 'text-[#4db8ff] hover:text-[#8cd7ff] underline cursor-pointer',
table: 'border-collapse table-auto w-full my-4',
tableCell: 'border border-[#3e3e42] px-3 py-2 text-[#e4e4e4] min-w-[100px]',
tableCellHeader: 'border border-[#3e3e42] px-3 py-2 text-[#e4e4e4] font-bold bg-[#2d2d30]',
};
interface LexicalViewerProps {
content: string;
}
function HeadingIdPlugin() {
const [editor] = useLexicalComposerContext();
useEffect(() => {
// Add data attribute and ID to heading elements for TOC
const updateHeadings = () => {
const headings = document.querySelectorAll('.lexical-viewer h1, .lexical-viewer h2, .lexical-viewer h3');
headings.forEach((heading, index) => {
if (heading instanceof HTMLElement) {
heading.setAttribute('data-lexical-heading', 'true');
if (!heading.id) {
const text = heading.textContent || '';
heading.id = `heading-${index}-${text.toLowerCase().replace(/\s+/g, '-').slice(0, 30)}`;
}
}
});
};
// Initial update with delay
setTimeout(updateHeadings, 100);
// Also register mutation listener
const unregister = editor.registerMutationListener(HeadingNode, () => {
setTimeout(updateHeadings, 50);
});
// Update periodically as backup
const interval = setInterval(updateHeadings, 1000);
return () => {
unregister();
clearInterval(interval);
};
}, [editor]);
return null;
}
function ContentPlugin({ content }: { content: string }) {
const [editor] = useLexicalComposerContext();
useEffect(() => {
try {
// Try to parse as JSON first (new format with formatting)
const editorState = editor.parseEditorState(content);
editor.setEditorState(editorState);
} catch {
// Fallback to plain text (legacy format)
editor.update(() => {
const root = $getRoot();
root.clear();
const lines = content.split('\n');
lines.forEach((line) => {
const paragraph = $createParagraphNode();
if (line.trim() === '') {
// Empty line for spacing
paragraph.append($createTextNode(''));
} else {
const text = $createTextNode(line);
paragraph.append(text);
}
root.append(paragraph);
});
});
}
// Make editor read-only
editor.setEditable(false);
}, [editor, content]);
return null;
}
function onError(error: Error) {
console.error('Lexical Viewer Error:', error);
}
export function LexicalViewer({ content }: LexicalViewerProps) {
const initialConfig = {
namespace: 'WikiViewer',
theme: viewerTheme,
onError,
editable: false,
nodes: [
HeadingNode,
ListNode,
ListItemNode,
QuoteNode,
CodeNode,
CodeHighlightNode,
LinkNode,
AutoLinkNode,
TableNode,
TableCellNode,
TableRowNode,
],
};
return (
<div className="prose prose-invert max-w-none">
<LexicalComposer initialConfig={initialConfig}>
<RichTextPlugin
contentEditable={
<ContentEditable
className="text-[#e4e4e4] text-base focus:outline-none lexical-viewer"
/>
}
placeholder={null}
ErrorBoundary={LexicalErrorBoundary}
/>
<ContentPlugin content={content} />
<HeadingIdPlugin />
</LexicalComposer>
</div>
);
}
+55
View File
@@ -0,0 +1,55 @@
import { useTOC } from './hooks/useTOC';
export function RightSidebar() {
const { headings, activeId, setActiveId } = useTOC();
const handleClick = (e: React.MouseEvent<HTMLAnchorElement>, id: string) => {
e.preventDefault();
const element = document.getElementById(id);
if (element) {
element.scrollIntoView({ behavior: 'smooth', block: 'start' });
setActiveId(id);
// Update URL hash without triggering scroll
window.history.pushState(null, '', `#${id}`);
}
};
if (headings.length === 0) {
return (
<aside className="w-64 fixed top-0 right-0 h-screen bg-[#252526] border-l border-[#3e3e42] overflow-y-auto z-10">
<div className="p-4 mt-14">
<h2 className="text-sm font-semibold text-[#e4e4e4] mb-4">이 문서의 내용</h2>
<p className="text-xs text-[#9d9d9d]">헤딩이 없습니다</p>
</div>
</aside>
);
}
return (
<aside className="w-64 fixed top-0 right-0 h-screen bg-[#252526] border-l border-[#3e3e42] overflow-y-auto z-10">
<div className="p-4 mt-14">
<h2 className="text-sm font-semibold text-[#e4e4e4] mb-4">이 문서의 내용</h2>
<nav>
<ul className="space-y-2">
{headings.map((heading) => (
<li
key={heading.id}
className={heading.level === 2 ? 'pl-3' : heading.level === 3 ? 'pl-6' : ''}
>
<a
href={`#${heading.id}`}
className={`text-sm block py-1 hover:text-[#4db8ff] transition-colors ${
activeId === heading.id ? 'text-[#4db8ff] font-semibold' : 'text-[#9d9d9d]'
}`}
onClick={(e) => handleClick(e, heading.id)}
>
{heading.text}
</a>
</li>
))}
</ul>
</nav>
</div>
</aside>
);
}
+100
View File
@@ -0,0 +1,100 @@
import { useEffect, useState } from 'react';
export interface TOCItem {
id: string;
text: string;
level: number;
}
export function useTOC() {
const [headings, setHeadings] = useState<TOCItem[]>([]);
const [activeId, setActiveId] = useState<string>('');
useEffect(() => {
// Find all heading elements in the content area
const updateHeadings = () => {
// Try both with and without data-lexical-heading attribute
const headingElements = document.querySelectorAll('h1, h2, h3');
const items: TOCItem[] = [];
headingElements.forEach((element, index) => {
if (element instanceof HTMLElement) {
const tagName = element.tagName.toLowerCase();
const level = parseInt(tagName.charAt(1));
const text = element.textContent || '';
// Add data attribute if missing
if (!element.hasAttribute('data-lexical-heading')) {
element.setAttribute('data-lexical-heading', 'true');
}
// Add ID if it doesn't exist
if (!element.id) {
element.id = `heading-${index}-${text.toLowerCase().replace(/\s+/g, '-').slice(0, 30)}`;
}
items.push({
id: element.id,
text,
level,
});
}
});
setHeadings(items);
};
// Initial update with delay to ensure DOM is ready
const initialTimer = setTimeout(updateHeadings, 500);
// Additional updates to catch late-rendered content
const secondTimer = setTimeout(updateHeadings, 1000);
const thirdTimer = setTimeout(updateHeadings, 2000);
// Update on content changes (use MutationObserver)
const observer = new MutationObserver(() => {
// Debounce updates
setTimeout(updateHeadings, 100);
});
const contentArea = document.querySelector('[contenteditable="true"]') || document.querySelector('.lexical-viewer');
if (contentArea) {
observer.observe(contentArea, {
childList: true,
subtree: true,
characterData: true,
});
}
// Track scroll position for active heading
const handleScroll = () => {
const headingElements = document.querySelectorAll('h1[data-lexical-heading], h2[data-lexical-heading], h3[data-lexical-heading]');
const scrollPosition = window.scrollY + 150; // Offset for better UX
let activeHeadingId = '';
headingElements.forEach((element) => {
if (element instanceof HTMLElement && element.offsetTop <= scrollPosition) {
activeHeadingId = element.id;
}
});
if (activeHeadingId) {
setActiveId(activeHeadingId);
}
};
window.addEventListener('scroll', handleScroll);
// Initial scroll check
setTimeout(handleScroll, 200);
return () => {
clearTimeout(initialTimer);
clearTimeout(secondTimer);
clearTimeout(thirdTimer);
observer.disconnect();
window.removeEventListener('scroll', handleScroll);
};
}, []); // Only run once on mount
return { headings, activeId, setActiveId };
}
+1
View File
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>

After

Width:  |  Height:  |  Size: 4.0 KiB

+3
View File
@@ -0,0 +1,3 @@
// Tailwind CSS v4 uses CSS-based configuration
// No config file is needed for basic setup
export default {}
+28
View File
@@ -0,0 +1,28 @@
{
"compilerOptions": {
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
"target": "ES2022",
"useDefineForClassFields": true,
"lib": ["ES2022", "DOM", "DOM.Iterable"],
"module": "ESNext",
"types": ["vite/client"],
"skipLibCheck": true,
/* Bundler mode */
"moduleResolution": "bundler",
"allowImportingTsExtensions": true,
"verbatimModuleSyntax": true,
"moduleDetection": "force",
"noEmit": true,
"jsx": "react-jsx",
/* Linting */
"strict": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"erasableSyntaxOnly": true,
"noFallthroughCasesInSwitch": true,
"noUncheckedSideEffectImports": true
},
"include": ["src"]
}
+7
View File
@@ -0,0 +1,7 @@
{
"files": [],
"references": [
{ "path": "./tsconfig.app.json" },
{ "path": "./tsconfig.node.json" }
]
}
+26
View File
@@ -0,0 +1,26 @@
{
"compilerOptions": {
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
"target": "ES2023",
"lib": ["ES2023"],
"module": "ESNext",
"types": ["node"],
"skipLibCheck": true,
/* Bundler mode */
"moduleResolution": "bundler",
"allowImportingTsExtensions": true,
"verbatimModuleSyntax": true,
"moduleDetection": "force",
"noEmit": true,
/* Linting */
"strict": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"erasableSyntaxOnly": true,
"noFallthroughCasesInSwitch": true,
"noUncheckedSideEffectImports": true
},
"include": ["vite.config.ts"]
}
+13
View File
@@ -0,0 +1,13 @@
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
// https://vite.dev/config/
export default defineConfig({
plugins: [
react({
babel: {
plugins: [['babel-plugin-react-compiler']],
},
}),
],
})