docs(工程文档): 格式化文档表格

Co-authored-by: LingandRX <LingandRX@users.noreply.github.com>

.github/CODING_STANDARDS.md

@@ -285,8 +285,7 @@ import { useThemeMode } from '@/providers/ThemeModeProvider';
 import { FeatureConfig, FEATURES } from '@/config/features';
 import { storageUtil } from '@/utils/chromeStorage';
 // 5. i18n
-import { useTranslation } from 'react-i18next';
-import { normalizeLanguage, SUPPORTED_LANGUAGES } from '@/i18n';
+import { useI18n } from '@/utils/chromeI18n';
 // 6. 本地组件
 import TextMode from './TextMode';
 import { ZONES } from './constants';
@@ -295,7 +294,7 @@ import SwitchButtonGroup from '@/components/SwitchButtonGroup';
 import { Button } from '@/components/ui/button';
 // 8. 工具函数 / Hook
 import { cn } from '@/lib/utils';
-import { useLazyTranslation } from '@/utils/useLazyTranslation';
+import { useStorageState } from '@/utils/useStorageState';
 // 9. 类型
 import type { PageType, StorageSchema } from '@/types/storage';
 ```
@@ -401,22 +400,22 @@ className={cn(
 
 ## 5. 错误处理
 
-### 5.1 工具函数：结果对象模式
+### 5.1 工具函数：可恢复错误返回可判断结果
 
-工具函数**不抛异常**，返回包含 `hasError` 和 `error` 字段的结果对象：
+可恢复的解析/校验错误应返回可判断的结果，避免工具层直接弹 Toast。确需保留底层异常的函数
+（如 `formatJson` / `minifyJson`）必须在页面 Hook 或 UI 层捕获并转换为用户提示：
 
 ```typescript
-// ✅ 结果对象模式
-export function markdownToHtml(markdown: string): MarkdownToHtmlResult {
+// ✅ 可恢复校验返回错误消息，调用方据此展示 UI
+export function validateJson(text: string): string | null {
+  if (!text.trim()) {
+    return null;
+  }
   try {
-    ...
-    return { html, originalLength, htmlLength, hasError: false };
-  } catch (error) {
-    return {
-      html: '', ...
-      hasError: true,
-      error: error instanceof Error ? error.message : 'Markdown 解析失败',
-    };
+    JSON.parse(text.trim());
+    return null;
+  } catch (e) {
+    return e instanceof SyntaxError ? e.message : 'Invalid JSON';
   }
 }
 ```
@@ -658,7 +657,7 @@ export function useTimestampConverter(): UseTimestampConverterReturn { ... }
 
 ```
 src/utils/useStorageState.ts          — Chrome Storage 状态持久化
-src/utils/useLazyTranslation.ts       — i18n 懒加载
+src/utils/chromeI18n.ts               — chrome.i18n wrapper 与 useI18n
 src/utils/useContextMenuData.ts       — 右键菜单数据
 src/utils/useDebounce.ts              — 防抖
 src/pages/Timestamp/useTimestampConverter.ts    — 页面级 Hook
@@ -671,43 +670,48 @@ src/pages/StorageCleaner/useStorageCleaner.ts  — 页面级 Hook
 
 ### 9.1 翻译键格式
 
-- 命名空间：`common`（默认）、`features`
-- 翻译键格式：`namespace:key`（如 `features:timestamp.title`）
-- 语言：`zh`（默认）、`en`
+- 使用 Chrome 扩展标准的 `chrome.i18n`，通过 `src/utils/chromeI18n.ts` 暴露 `useI18n`
+- 翻译 key 存放在 `public/_locales/zh_CN/messages.json`
+- 直接 key：`t('dashboard_title')` → 查找 `dashboard_title`
+- 命名空间兼容写法：`t('common:buttons.search')` → 查找 `common_buttons_search`
+- 命名空间参数：`useI18n(['common', 'features'])` 会尝试 `common_key`、`features_key`
 
 ### 9.2 翻译文件结构
 
 ```
-i18n/locales/{zh,en}/common.json           — 全局通用翻译
-i18n/locales/{zh,en}/features.json         — 功能模块标题和描述
-i18n/locales/{zh,en}/{功能名}.json         — 各功能独立翻译
+public/_locales/zh_CN/messages.json        — Chrome 扩展默认语言包
+wxt.config.ts                              — manifest.default_locale = 'zh_CN'
 ```
 
 ### 9.3 使用方式
 
 ```typescript
-// ✅ 页面组件 — 使用 useLazyTranslation
-import { useLazyTranslation } from '@/utils/useLazyTranslation';
+// ✅ 页面组件 / 子组件 — 使用 useI18n
+import { useI18n } from '@/utils/chromeI18n';
 
 export default function Index() {
-  const { t } = useLazyTranslation('timestamp');
-  return <h1>{t('timestamp:title')}</h1>;
+  const { t } = useI18n('timestamp');
+  return <h1>{t('timestamp_title')}</h1>;
 }
 
-// ✅ 全局组件 — 使用 useTranslation
-import { useTranslation } from 'react-i18next';
-
-export function TopBar() {
-  const { t } = useTranslation(['common', 'features']);
-  return <span>{t('common:settings')}</span>;
+// ✅ 带占位符
+export function NotFoundMessage() {
+  const { t } = useI18n('router');
+  return <p>{t('router_notFoundDescription', { entryPointType: 'popup' })}</p>;
 }
 ```
 
 ### 9.4 添加新翻译
 
-1. 在 `i18n/locales/{zh,en}/features.json` 添加功能标题和描述
-2. 创建 `i18n/locales/{zh,en}/{功能名}.json` 添加功能专属翻译
-3. 在 `utils/useLazyTranslation.ts` 的 `localeModules` 中注册新命名空间
+1. 在 `public/_locales/zh_CN/messages.json` 添加 Chrome 扩展格式的消息：
+   ```json
+   {
+     "feature_title": { "message": "功能标题" },
+     "feature_description": { "message": "功能描述" }
+   }
+   ```
+2. key 使用下划线分隔，避免点号；`useI18n` 会把 `namespace:key.path` 兼容转换为下划线
+3. `chrome.i18n` 不支持运行时动态切换语言，浏览器语言变化后需要刷新扩展页面
 
 ---
 
@@ -762,22 +766,335 @@ const [themeMode, setThemeMode, isInitialized] = useStorageState(
 
 ---
 
-## 11. 文件组织
+## 11. 页面开发规范
 
-### 11.1 页面组件结构
+### 11.1 目录结构（按复杂度分级）
+
+#### 简单页面（单一功能，无子模式）
+
+适用于 Timestamp、Jwt、TextStatistics、RightClickRestorer 等：
 
 ```
 src/pages/FeatureName/
-├── index.tsx              # 页面 UI（纯展示，使用 shadcn/ui 组件）
-├── useFeatureName.ts      # 业务逻辑 Hook（状态管理 + 转换逻辑）
-├── constants.ts           # 常量定义（可选）
-├── LiveClock.tsx          # 子组件（可选）
-├── ResultView.tsx         # 子组件（可选）
-└── __tests__/             # 测试文件
-    └── index.test.tsx
+├── index.tsx              # 页面入口组件（default export）
+├── useFeatureName.ts      # 业务逻辑 Hook（命名导出）
+├── constants.ts           # 常量定义（可选，命名导出）
+├── SubComponent.tsx       # 子组件（可选，default export）
+└── __tests__/
+    └── index.test.tsx     # 页面集成测试
 ```
 
-### 11.2 目录职责
+#### 中等页面（含多个子模式/标签页切换）
+
+适用于 Base64Converter、StorageCleaner 等：
+
+```
+src/pages/FeatureName/
+├── index.tsx              # 页面入口（模式路由 + 顶层布局）
+├── useFeatureName.ts      # 业务逻辑 Hook（命名导出）
+├── SubModeA.tsx           # 子模式组件
+├── SubModeB.tsx           # 子模式组件
+├── SubComponent.tsx       # 可复用子组件
+└── __tests__/
+    ├── index.test.tsx
+    └── SubModeA.test.tsx
+```
+
+#### 复杂页面（Context + 多组件协作）
+
+适用于 QrCode、JsonTools 等：
+
+```
+src/pages/FeatureName/
+├── index.tsx              # 页面入口（Provider + 布局）
+├── types.ts               # 页面专属类型定义
+├── constants.ts           # 常量（可选）
+├── contexts/              # React Context 定义
+│   └── FeatureContext.ts
+├── hooks/                 # 页面专属 Hooks
+│   └── useFeature.ts
+├── components/            # 页面专属子组件
+│   ├── PanelA.tsx
+│   └── PanelB.tsx
+└── __tests__/
+    ├── index.test.tsx
+    └── useFeature.test.ts
+```
+
+#### 特殊情况（单个文件即可）
+
+功能极简的页面（如 Dashboard），仅需 `index.tsx` 一个文件。当 `index.tsx` 超过 **150 行**时，应拆分为 UI + Hook 模式。
+
+---
+
+### 11.2 页面入口组件（`index.tsx`）规范
+
+#### 组件命名
+
+- 页面入口组件**统一使用 `Index` 作为函数名**，通过 `export default` 导出
+- 使用 `export default function Index()` 而非匿名默认导出
+- **禁止**混用 `XxxPage` 命名（当前 `RightClickRestorerPage`、`DashboardPage` 不合规范，应统一为 `Index`）
+
+```typescript
+// ✅ 正确
+export default function Index() { ... }
+
+// ❌ 错误 — 命名不一致
+export default function RightClickRestorerPage() { ... }
+export default function DashboardPage() { ... }
+```
+
+#### 组件职责
+
+`index.tsx` 只负责三件事：
+
+1. **获取翻译函数**（`useI18n`）
+2. **调用业务 Hook** 获取状态和操作方法
+3. **渲染 UI 布局**（纯展示，无业务逻辑）
+
+```typescript
+// ✅ 标准页面入口模板
+import { useI18n } from '@/utils/chromeI18n';
+import { useFeatureName } from './useFeatureName';
+
+export default function Index() {
+  const { t } = useI18n('featureName');
+  const { state, actions } = useFeatureName();
+
+  return (
+    <div className="p-4 w-full flex flex-col space-y-4 select-none">
+      {/* 纯 UI 渲染 */}
+    </div>
+  );
+}
+```
+
+#### 禁止在 `index.tsx` 中编写的内容
+
+- ❌ `useState` / `useMemo` / `useCallback`（应放在 Hook 中）
+- ❌ 数据转换/格式化逻辑
+- ❌ 异步请求/副作用
+- ❌ 超过 3 行的条件判断逻辑
+
+---
+
+### 11.3 业务 Hook 规范（`useFeatureName.ts`）
+
+#### 命名
+
+- 文件名：`useXxx.ts`（驼峰命名）
+- Hook 函数名：`useXxx()`
+- 返回值接口：`UseXxxReturn`
+
+```typescript
+// ✅ 标准 Hook 结构
+export interface UseTimestampConverterReturn {
+  mode: 'ts2dt' | 'dt2ts';
+  input: string;
+  result: string;
+  error: string;
+  setMode: (mode: 'ts2dt' | 'dt2ts') => void;
+  setInput: (value: string) => void;
+  handleUseNow: (now: number) => void;
+}
+
+export function useTimestampConverter(): UseTimestampConverterReturn {
+  // 所有业务逻辑在此
+}
+```
+
+#### Hook 内部结构（推荐顺序）
+
+```typescript
+export function useFeatureName(): UseFeatureNameReturn {
+  // 1. i18n
+  const { t } = useI18n('featureName');
+
+  // 2. 基础 state（useState）
+  const [mode, setMode] = useState<Mode>('default');
+  const [input, setInput] = useState('');
+
+  // 3. 持久化 state（useStorageState）
+  const [pageMode, setPageMode] = useStorageState('feature/pageMode', 'default', isValidMode);
+
+  // 4. 衍生数据（useMemo）— 响应式计算管线
+  const result = useMemo(() => {
+    // 自动计算，无需手动点击"转换"按钮
+  }, [input, mode]);
+
+  // 5. 事件处理（useCallback）
+  const handleAction = useCallback(() => { ... }, [deps]);
+
+  // 6. 副作用（useEffect）— 防抖、初始化、清理
+  useEffect(() => { ... }, [deps]);
+
+  // 7. 右键菜单数据（页面需要时）
+  useContextMenuData({ featureKey: 'featureName', onData: handleContextMenuData });
+
+  // 8. 返回
+  return { mode, input, result, setMode, setInput, handleAction };
+}
+```
+
+#### 防抖模式
+
+当输入框需要防抖时，在 Hook 中实现：
+
+```typescript
+// ✅ 防抖管道 — 在 useMemo 前定义
+const [input, setInput] = useState('');
+const [debouncedInput, setDebouncedInput] = useState('');
+
+useEffect(() => {
+  const handle = setTimeout(() => setDebouncedInput(input), 250);
+  return () => clearTimeout(handle);
+}, [input]);
+
+// 后续 useMemo 使用 debouncedInput 而非 input
+const result = useMemo(() => compute(debouncedInput), [debouncedInput]);
+```
+
+---
+
+### 11.4 常量文件规范（`constants.ts`）
+
+- 仅在常量超过 **3 个**或需要**导出类型**时创建
+- 使用 `as const` 确保字面量类型
+- 从 `as const` 数组派生联合类型
+
+```typescript
+// ✅ 标准常量文件
+export const DATE_FORMAT = 'YYYY/MM/DD HH:mm:ss';
+
+export const ZONES = ['Asia/Shanghai', 'America/New_York', 'Europe/London'] as const;
+
+export type UnitType = 'ms' | 's';
+export type ZoneType = (typeof ZONES)[number];
+```
+
+---
+
+### 11.5 子组件规范
+
+#### 何时拆分子组件
+
+- `index.tsx` 超过 **150 行**
+- 存在可复用的 UI 片段（如卡片、面板、结果展示区）
+- 需要 `React.memo` 优化的高频渲染区域
+
+#### 子组件 Props 模式
+
+```typescript
+// ✅ 继承 HTML 属性 + 业务 Props
+interface ResultViewProps extends React.HTMLAttributes<HTMLDivElement> {
+  result: string;
+  mode: 'ts2dt' | 'dt2ts';
+  showEmptyPlaceholder?: boolean;
+}
+
+// ✅ 使用 React.memo + displayName
+const ResultView = React.memo(
+  ({ result, mode, showEmptyPlaceholder = false, className, ...props }: ResultViewProps) => {
+    const { t } = useI18n('featureName');
+    // ...
+  },
+);
+ResultView.displayName = 'ResultView';
+export default ResultView;
+```
+
+#### 子组件内可以使用 Hook
+
+子组件可以独立调用 `useI18n`、`useSnackbar` 等全局 Hook，**不需要**通过 props 从父组件传递翻译函数或 toast 方法。
+
+---
+
+### 11.6 存储键命名规范
+
+页面使用的 Storage 键必须遵循 kebab-case 格式：`{功能名}/{用途}`。
+
+```typescript
+// ✅ 正确
+'base64Converter/pageMode';
+'base64Converter/fileMode/direction';
+'jsonTools/pageMode';
+'qrCode/urlExpanded';
+
+// ❌ 错误
+'base64ConverterPageMode';
+'json_tools_page_mode';
+```
+
+在 `types/storage.d.ts` 的 `StorageSchema` 中声明所有键。
+
+---
+
+### 11.7 模式切换通用模式
+
+当页面有多个子模式（标签页切换），统一使用以下模式：
+
+```typescript
+// ✅ 标准模式切换
+const VALID_MODES = ['modeA', 'modeB'] as const;
+type PageMode = (typeof VALID_MODES)[number];
+
+const isValidMode = (val: unknown): val is PageMode =>
+  typeof val === 'string' && (VALID_MODES as readonly string[]).includes(val);
+
+export default function Index() {
+  const { t } = useI18n('featureName');
+  const [pageMode, setPageMode] = useStorageState('feature/pageMode', 'modeA', isValidMode);
+
+  return (
+    <div className="p-4 w-full flex flex-col space-y-4 select-none">
+      <SwitchButtonGroup
+        value={pageMode}
+        options={[
+          { value: 'modeA', label: t('feature:modeA') },
+          { value: 'modeB', label: t('feature:modeB') },
+        ]}
+        onChange={(v: PageMode) => setPageMode(v)}
+        size="small"
+      />
+      {pageMode === 'modeA' ? <PanelA /> : <PanelB />}
+    </div>
+  );
+}
+```
+
+---
+
+### 11.8 页面布局约定
+
+- 所有页面根元素使用统一的外层容器：
+  ```
+  <div className="p-4 w-full flex flex-col space-y-4 select-none">
+  ```
+- 不需要 `<div className="min-h-screen bg-background ...">` — 该样式已由 `AppRoot` 提供
+- 不需要 `min-h-[500px]` 或固定高度（除非确有必要）
+- 卡片容器：`rounded-xl border border-border bg-card text-card-foreground shadow-sm`
+- 使用 `space-y-4` 管理纵向间距，不要手动 `mb-4`
+
+---
+
+### 11.9 页面开发检查清单
+
+新增功能页面时，逐项确认：
+
+1. ✅ 在 `types/storage.d.ts` 添加 `PageType` 联合类型
+2. ✅ 在 `config/features.tsx` 注册 `FEATURES` 配置（key、labelKey、icon、三种渲染模式组件）
+3. ✅ 创建页面目录，使用 `Index` 作为组件名
+4. ✅ 业务逻辑提取到 `useXxx.ts` Hook（index.tsx 不超过 150 行）
+5. ✅ 需要持久化的 UI 状态使用 `useStorageState`
+6. ✅ 常量 ≥3 个时提取到 `constants.ts`
+7. ✅ 在 `public/_locales/zh_CN/messages.json` 添加翻译
+8. ✅ 创建 `__tests__/index.test.tsx` 测试文件
+9. ✅ 如需新权限，更新 `wxt.config.ts` 的 `manifest.permissions`
+10. ✅ 运行 `npm run lint && npm run typecheck && npm run test` 全部通过
+
+---
+
+### 11.10 目录职责总览
 
 | 目录                 | 职责                                                         |
 | -------------------- | ------------------------------------------------------------ |
@@ -790,8 +1107,8 @@ src/pages/FeatureName/
 | `src/hooks/`         | 自定义 React Hooks                                           |
 | `src/utils/`         | 工具函数与服务抽象                                           |
 | `src/types/`         | TypeScript 类型声明                                          |
-| `src/lib/`           | 通用工具函数（cn、utils）                                    |
-| `public/`            | 静态资源                                                     |
+| `src/lib/`           | 通用工具函数与生成器库（cn、utils、generators）              |
+| `public/`            | 静态资源与 Chrome `_locales` 语言包                          |
 
 ---
 

.github/copilot-instructions.md

@@ -1,6 +1,6 @@
 # Copilot 指令
 
-基于 WXT 框架的浏览器扩展项目（React 19 + TypeScript），为开发者和测试人员提供效率工具：时间戳转换、存储清理、JWT 解析、JSON 工具、二维码、Base64、Markdown 等。
+基于 WXT 框架的浏览器扩展项目（React 19 + TypeScript），为开发者和测试人员提供效率工具：时间戳转换、存储清理、JWT 解析、JSON 工具、二维码、Base64、测试数据生成器等。
 
 ## 核心命令
 
@@ -56,7 +56,7 @@ Router 同时使用 `chrome.storage.local` 持久化和 `localStorage` 快照来
 
 ### 页面组件模式
 
-功能页面遵循 **UI + Hook 分离** 模式：
+功能页面遵循 **UI + Hook 分离** 模式，详见 [CODING_STANDARDS.md § 11](./CODING_STANDARDS.md#11-页面开发规范)：
 
 ```
 pages/FeatureName/
@@ -65,7 +65,7 @@ pages/FeatureName/
 └── constants.ts           # 常量定义（可选）
 ```
 
-- 页面组件调用 `useLazyTranslation('featureName')` 获取翻译函数
+- 页面组件调用 `useI18n('featureName')` 获取翻译函数
 - Hook 负责所有状态管理，通过返回值暴露给页面
 - 子组件可进一步拆分（如 `LiveClock.tsx`、`ResultView.tsx`）
 
@@ -74,10 +74,10 @@ pages/FeatureName/
 1. 在 `types/storage.d.ts` 的 `PageType` 联合类型中添加新成员
 2. 在 `config/features.tsx` 的 `FEATURES` 数组中添加配置（key、翻译键、图标、三种渲染模式组件）
 3. 在 `pages/` 目录创建页面组件（懒加载）：
-   - `index.tsx` — 使用 `useLazyTranslation` 的 UI 组件
+   - `index.tsx` — 使用 `useI18n` 的 UI 组件
    - `useFeatureName.ts` — 业务逻辑 Hook
    - `constants.ts` — 常量（可选）
-4. 在 `i18n/locales/{zh,en}/features.json` 添加翻译（复杂功能可新建独立 JSON 文件）
+4. 在 `public/_locales/zh_CN/messages.json` 添加 Chrome i18n 翻译
 5. 如需新权限，更新 `wxt.config.ts` 的 `manifest.permissions`
 6. 添加对应的单元测试
 
@@ -102,7 +102,7 @@ pages/FeatureName/
 
 ### 代码分割
 
-`wxt.config.ts` 通过 `manualChunksForHtmlOnly()` 自动分组 vendor 依赖（vendor-react、vendor-i18n、vendor-qr、vendor-dnd），无需手动配置。
+`wxt.config.ts` 通过 `manualChunksForHtmlOnly()` 自动分组 vendor 依赖（vendor-react、vendor-qr、vendor-dnd），无需手动配置。
 
 ### 代码风格
 
@@ -118,8 +118,7 @@ pages/FeatureName/
 - 全局变量：`vitest/globals`（describe、it、expect 等无需导入）
 - Setup 文件：`vitest.setup.ts` 自动 mock 以下内容：
   - `chrome.*` / `browser.*` API（storage、tabs、runtime、cookies 等）
-  - `react-i18next`（返回 key 作为翻译）
-  - `@/utils/useLazyTranslation`（返回 `ns:key` 格式）
+  - `@/utils/chromeI18n`（从 `public/_locales/zh_CN/messages.json` 加载真实翻译）
   - `window.matchMedia`
 - 测试文件命名：`__tests__/*.test.{ts,tsx}` 或 `*.test.{ts,tsx}`
 - 使用 `vi.mock()` 进行模块级 mock；避免重复 mock `vitest.setup.ts` 中已有的内容
@@ -127,12 +126,12 @@ pages/FeatureName/
 
 ### 国际化（i18n）
 
-- 命名空间：`common`（默认）、`features`
-- 翻译键格式：`namespace:key`（如 `features:timestamp.title`）
-- 语言：`zh`（默认）、`en`
-- 翻译文件：`i18n/locales/{zh,en}/{common,features}.json` + 各功能独立 JSON 文件
-- 使用 `useLazyTranslation` Hook 加载功能专属翻译
-- 回退策略：缺失的翻译键回退到 `zh`，若仍缺失则返回占位格式 `namespace:key`
+- 使用 Chrome 扩展标准 `chrome.i18n`
+- 默认语言目录：`public/_locales/zh_CN/messages.json`
+- 使用方式：`import { useI18n } from '@/utils/chromeI18n'`
+- 翻译键格式：直接 key（如 `timestamp_title`）；兼容 `namespace:key.path` 并转换为下划线
+- 回退策略：缺失翻译返回 key 本身，并在开发模式下记录 warning
+- 限制：`chrome.i18n` 跟随浏览器语言，不能在运行时动态切换语言
 
 ### WXT 生成文件
 

.gitignore

@@ -14,6 +14,11 @@ stats-*.json
 .wxt
 .vitest
 
+# Environment variables
+.env
+.env.local
+.env.*.local
+
 # Editor directories and files
 .vscode/*
 !.vscode/extensions.json
@@ -30,4 +35,16 @@ stats-*.json
 .qoder/*
 dev/*
 
-docs/*
+# Build outputs
+dist/
+build/
+
+# Test coverage
+coverage/
+
+# IDE files
+*.code-workspace
+
+# Other
+*.tsbuildinfo
+*.tsxbuildinfo

.husky/pre-commit

@@ -1 +1,5 @@
-npx lint-staged
+# 后台运行类型检查，结果输出到 stderr 但不阻塞提交
+npx tsc --noEmit &
+
+# 前台运行 lint-staged（自动修复 + 格式化）
+npx lint-staged

.husky/pre-push

@@ -0,0 +1,13 @@
+# pre-push: 严格检查，阻塞有问题的代码推送到远程
+# 类型检查（全项目，因为类型错误可能跨文件传播）
+npx tsc --noEmit
+
+# ESLint 严格检查（仅检查本次推送的变更文件，不阻塞不相关的旧代码）
+# 新分支无 upstream 时，回退到与 origin/main 对比
+MERGE_BASE=$(git merge-base HEAD @{upstream} 2>/dev/null || git merge-base HEAD origin/main 2>/dev/null)
+if [ -n "$MERGE_BASE" ]; then
+  CHANGED_FILES=$(git diff --name-only --diff-filter=d "$MERGE_BASE" HEAD -- '*.ts' '*.tsx' '*.js' '*.jsx' '*.mjs')
+  if [ -n "$CHANGED_FILES" ]; then
+    echo "$CHANGED_FILES" | xargs npx eslint --max-warnings=0
+  fi
+fi

AGENTS.md

@@ -1,6 +1,6 @@
 # AGENTS.md
 
-WXT 浏览器扩展项目 (React 19 + TypeScript)。提供时间戳转换、存储清理、JWT 解析、JSON 工具、二维码、Base64、Markdown 等测试效率工具。
+WXT 浏览器扩展项目 (React 19 + TypeScript)。提供时间戳转换、存储清理、JWT 解析、JSON 工具、二维码、Base64、测试数据生成器等测试效率工具。
 
 ## 核心命令
 
@@ -54,23 +54,60 @@ src/                   # 源代码根目录
   utils/                 # 工具函数与服务抽象
   types/                 # TypeScript 类型声明
   lib/                   # 通用工具函数（cn、utils）
+  workers/               # Web Worker（数据生成等耗时任务）
 public/                # 静态资源（图标、_locales 等）
 ```
 
 ### 页面组件模式
 
-典型功能页面遵循 **UI + Hook 分离** 模式：
+典型功能页面遵循 **UI + Hook 分离** 模式。详见 [CODING_STANDARDS.md § 11](./.github/CODING_STANDARDS.md#11-页面开发规范)。
 
 ```
 src/pages/FeatureName/
-├── index.tsx              # 页面 UI（纯展示，使用 shadcn/ui 组件）
+├── index.tsx              # 页面 UI（纯展示，仅负责渲染布局）
 ├── useFeatureName.ts      # 业务逻辑 Hook（状态管理 + 转换逻辑）
-└── constants.ts           # 常量定义
+├── constants.ts           # 常量定义（可选，≥3 个常量时创建）
+└── __tests__/
+    └── index.test.tsx
 ```
 
-- 页面组件调用 `useLazyTranslation('featureName')` 获取翻译函数
+- 页面入口组件统一命名为 `Index`，通过 `export default function Index()` 导出
 - Hook 负责所有状态管理和业务逻辑，通过返回值暴露给页面
-- 子组件可进一步拆分（如 `LiveClock.tsx`、`ResultView.tsx`）
+- 子组件可以独立调用 `useI18n` 等全局 Hook
+- 当 `index.tsx` 超过 150 行时，必须拆分为 UI + Hook 模式
+- 复杂页面可增加 `contexts/`、`hooks/`、`components/` 子目录
+
+### 测试数据生成器模块
+
+```
+src/pages/TestDataGenerator/
+├── index.tsx                    # 主页面（字段配置 + 标签页切换）
+├── hooks/useGenerator.ts        # Web Worker 管理 Hook（创建、复用、通信、销毁）
+└── components/
+    ├── FieldList.tsx            # 字段列表（虚拟滚动 + @dnd-kit 拖拽排序 + 规则保存）
+    ├── FieldItem.tsx            # 字段卡片展示
+    ├── FieldEditor.tsx          # 字段编辑器（名称校验、生成器选择、参数配置）
+    ├── GeneratorSelector.tsx    # 生成器选择器（分类 + 搜索）
+    ├── GeneratorConfig.tsx      # 生成器参数表单（动态渲染 string/number/boolean/select/array）
+    ├── GenerateOptions.tsx      # 生成选项（数量、格式）
+    ├── GenerateButton.tsx       # 生成按钮 + 进度条
+    ├── DataPreview.tsx          # 示例数据预览（JSON 语法高亮）
+    ├── ResultPanel.tsx          # 生成结果状态面板
+    ├── ExportPanel.tsx          # 导出面板（复制/下载 JSON/CSV）
+    └── RuleManager.tsx          # 规则管理（CRUD、搜索、导入/导出）
+
+src/utils/
+├── ruleStorage.ts               # 规则持久化存储（localStorage）
+└── dataExporter.ts              # 数据导出工具（JSON/CSV 转换、下载、剪贴板）
+
+src/lib/generators/              # 内置生成器定义（个人信息、企业、技术、基础类型）
+
+src/workers/
+└── generator.worker.ts          # 数据生成 Web Worker
+
+src/types/
+└── testDataGenerator.ts         # 类型定义（FieldConfig, DataRule, GeneratorDefinition 等）
+```
 
 ## 关键架构决策
 
@@ -88,7 +125,7 @@ src/pages/FeatureName/
 
 **浏览器兼容**: 优先使用 `wxt/browser` 导出的 `browser` 对象，而非原生 `chrome` API。
 
-**代码分割**: `wxt.config.ts` 通过 `manualChunksForHtmlOnly()` 自动分组依赖（vendor-react、vendor-i18n、vendor-qr 等），无需手动配置。
+**代码分割**: `wxt.config.ts` 通过 `manualChunksForHtmlOnly()` 自动分组依赖（vendor-react、vendor-qr、vendor-dnd 等），无需手动配置。
 
 ## 测试环境
 
@@ -96,35 +133,37 @@ src/pages/FeatureName/
 - 全局变量: `vitest/globals` (describe, it, expect 等无需导入)
 - Setup 文件: `vitest.setup.ts` 自动 mock:
   - `chrome.*` / `browser.*` API (storage, tabs, runtime, cookies 等)
-  - `react-i18next` (返回 key 作为翻译)
-  - `@/utils/useLazyTranslation` (返回 `ns:key` 格式翻译)
+  - `@/utils/chromeI18n` (从 `public/_locales/zh_CN/messages.json` 加载真实翻译)
   - `window.matchMedia`
 - 测试文件命名: `__tests__/*.test.{ts,tsx}` 或 `*.test.{ts,tsx}`
 - Mock 模式: 使用 `vi.mock()` 进行模块级 mock，避免在测试文件中重复 mock 代码
 - 测试工具: `@testing-library/react` + `@testing-library/user-event` 进行组件测试
 
-## i18n
+## i18n (chrome.i18n)
 
-- 命名空间: `common` (默认), `features`
-- 翻译键格式: `namespace:key` (如 `features:timestamp.title`)
-- 语言: `zh` (默认), `en`
-- 翻译文件结构:
-  - `i18n/locales/{zh,en}/common.json` - 全局通用翻译
-  - `i18n/locales/{zh,en}/features.json` - 功能模块标题和描述
-  - `i18n/locales/{zh,en}/{功能名}.json` - 各功能独立翻译（如 timestamp.json, storageCleaner.json 等）
-- 添加新翻译: 编辑 `i18n/locales/{zh,en}/{common,features}.json` 及对应功能独立 JSON
-- 使用 `useLazyTranslation` hook 加载功能独立翻译，返回 `ns:key` 格式
-- 回退策略: 当翻译 key 在目标语言缺失时，回退到默认语言 `zh`；若默认语言也缺失，返回占位格式 `namespace:key` 并在开发模式下记录 warning
+项目使用 Chrome 扩展标准的 `chrome.i18n` API 进行本地化，通过 `src/utils/chromeI18n.ts` 提供类型安全的 React Hook 包装。
+
+- **翻译文件**: `public/_locales/zh_CN/messages.json`（Chrome 扩展标准格式）
+- **默认语言**: `zh_CN`（在 `wxt.config.ts` 的 `manifest.default_locale` 中配置）
+- **使用方式**: `import { useI18n } from '@/utils/chromeI18n'`
+- **翻译键格式**:
+  - 直接 key: `t('dashboard_title')` → 查找 `dashboard_title`
+  - 命名空间格式（兼容旧用法）: `t('common:buttons.search')` → 查找 `common_buttons_search`
+  - 带命名空间参数: `useI18n(['common', 'features'])`，会自动尝试 `common_key`、`features_key`
+- **占位符支持**: `t('router_notFoundDescription', { entryPointType: 'popup' })`
+- **Hook 返回值**: `{ t, i18n: { language, changeLanguage }, isLoaded }`
+- **回退策略**: 当翻译 key 未命中时，返回 key 本身（开发模式下在控制台记录 warning）
+- **限制**: `chrome.i18n` 无法动态切换语言，语言跟随浏览器设置，切换后需刷新页面
 
 ## 新功能开发清单
 
 1. 在 `src/types/storage.d.ts` 添加 `PageType` 联合类型
 2. 在 `src/config/features.tsx` 的 `FEATURES` 数组添加配置（指定 key、翻译键、图标、三种渲染模式的组件）
 3. 在 `src/pages/` 创建页面组件 (懒加载)：
-   - `index.tsx` — UI 组件，使用 `useLazyTranslation` 获取翻译
+   - `index.tsx` — UI 组件，使用 `useI18n` 获取翻译
    - `useFeatureName.ts` — 业务逻辑 Hook
    - `constants.ts` — 常量（可选）
-4. 在 `i18n/locales/{zh,en}/features.json` 添加翻译（复杂功能可新建独立 JSON）
+4. 在 `public/_locales/zh_CN/messages.json` 添加翻译
 5. 如需新权限，更新 `wxt.config.ts` 的 `manifest.permissions`
 6. 添加对应的单元测试
 
@@ -137,11 +176,13 @@ src/pages/FeatureName/
 - 图标: 使用 `lucide-react` 图标库
 - 格式: Prettier (`.prettierrc`: 100 字符宽, 单引号, 尾逗号 all, LF 换行)
 - ESLint 使用 `typescript-eslint` 的 `projectService: true`（无需手动维护 project 路径）
+- **Git Commit**: 必须使用中文描述，遵循 Conventional Commits 规范（如 `fix(组件名): 描述`、`feat(功能名): 描述`）
 
 ## 关键外部库（非显而易见的）
 
 - `@webext-core/messaging` — 扩展消息通信
-- `@dnd-kit` — 拖拽排序（用于页面顺序管理）
+- `@dnd-kit` — 拖拽排序（用于页面顺序管理和字段列表排序）
 - `qrious` + `qr-scanner` — 二维码生成与解析
 - `dayjs` — 日期处理（时间戳转换）
 - `sonner` — Toast 通知（替代传统 snackbar）
+- Web Worker — 批量数据生成（`src/workers/generator.worker.ts`），避免阻塞 UI 线程

CLAUDE.md

@@ -0,0 +1 @@
+@AGENT.md

README.md

@@ -8,61 +8,72 @@
 
 ## 功能特性
 
-### 🚀 Dashboard 首页
+### Dashboard 首页
 
 - **工具导航**: 快速访问所有可用工具.
 - **个性化定制**: 支持自定义工具的排序和可见性.
 - **实时预览**: 在卡片上直接查看实时数据（如当前时间戳）.
 
-### ⏰ 时间戳转换工具
+### 时间戳转换工具
 
 - **实时显示**: 毫秒级精度显示当前系统时间.
 - **双向转换**: 日期字符串与 Unix 时间戳（秒/毫秒）之间的无缝转换.
 - **多时区支持**: 预设常用时区（亚洲/上海、美洲/纽约、欧洲/伦敦），支持快速切换.
 - **快捷操作**: 一键复制转换结果，支持多种格式.
 
-### 🧹 存储清理工具
+### 存储清理工具
 
 - **智能识别**: 自动检测并显示当前活动标签页的域名.
 - **全面清理**: 支持一键清理 localStorage、sessionStorage、IndexedDB、Cookies、Cache Storage 和 Service Workers.
 - **细粒度控制**: 可根据需要选择特定的清理项.
 - **自动刷新**: 提供清理后自动刷新页面的选项，确保状态同步.
 
-### 📝 文本统计工具
+### 文本统计工具
 
 - **实时分析**: 键入即统计，无需额外操作.
 - **多维指标**: 统计字符数、单词数、行数以及精确的字节大小.
 - **性能优化**: 采用高性能分词算法，支持大文本处理.
 
-### 🔑 JWT 解析工具
+### JWT 解析工具
 
 - **快速解码**: 自动解析 JSON Web Token 的 Header 和 Payload.
 - **格式化显示**: 以着色和格式化的 JSON 视图展示数据，方便阅读.
 - **安全检查**: 自动去除 `Bearer` 前缀，处理异常输入并提供友好提示.
 - **签名查看**: 展示 JWT 签名部分，辅助验证令牌完整性.
 
-### 🖱️ 右键恢复工具
+### 右键恢复工具
 
 - **当前页面检测**: 自动识别当前活动标签页的域名.
 - **一键恢复**: 解除网站对右键菜单的限制，恢复复制、粘贴等基础操作.
 - **状态可视化**: 通过 Badge 组件直观展示当前页面的锁定/解锁状态.
 
-### 🖼️ 二维码工具
+### 二维码工具
 
 - **生成器**: 将当前 URL 或自定义文本快速转换为二维码，支持下载.
 - **解析器**: 支持通过上传图片或粘贴图片来解析二维码内容.
 
-### 🔄 JSON 工具
+### JSON 工具
 
 - **差异比较**: 对比两段 JSON 数据，高亮展示差异.
 - **格式化**: 支持 JSON 美化、压缩、转 YAML / TOML.
 
-### 🧰 Base64 转换器
+### Base64 转换器
 
 - **文本编解码**: 支持文本内容的 Base64 编码与解码.
 - **文件转换**: 支持文件与 Base64 字符串互转.
 - **图像预览**: 支持图片 Base64 编码与实时预览.
 
+### 测试数据生成器
+
+- **可视化字段配置**: 通过 UI 界面定义数据字段，支持拖拽排序、最多 40 个字段.
+- **丰富的内置生成器**: 涵盖个人信息（姓名、手机、邮箱）、企业数据（公司名、职位）、技术数据（IP、MAC 地址、UUID）、基础类型（数字、日期、枚举）等多个分类.
+- **灵活的参数配置**: 每个生成器支持自定义参数（如数字范围、日期格式、枚举值列表等）.
+- **空值率与唯一性**: 可为非必填字段设置空值率，支持字段唯一性约束.
+- **规则管理**: 保存、加载、编辑、复制、导入/导出字段配置规则，方便复用.
+- **批量生成**: 支持 1 ~ 100,000 条数据生成，通过 Web Worker 异步处理避免阻塞 UI.
+- **实时预览**: 配置字段后即时预览示例数据结构.
+- **多格式导出**: 支持 JSON 和 CSV 格式，提供复制到剪贴板和下载文件两种导出方式.
+
 ## 技术栈
 
 - **框架**: [WXT (Web Extension Toolkit)](https://wxt.dev/)
@@ -70,11 +81,13 @@
 - **UI 组件**: shadcn/ui (基于 Radix UI 的无头组件库)
 - **样式**: Tailwind CSS + class-variance-authority + cn() 工具函数
 - **日期处理**: dayjs (集成 UTC 和 Timezone 插件)
-- **国际化**: i18next + react-i18next
+- **国际化**: Chrome `chrome.i18n` + `public/_locales/zh_CN/messages.json`
 - **通信**: @webext-core/messaging
 - **存储**: Chrome Storage API (类型安全封装)
 - **解析引擎**: qr-scanner (二维码解析), qrious (二维码生成)
 - **测试**: Vitest + Testing Library
+- **拖拽排序**: @dnd-kit/core + @dnd-kit/sortable
+- **异步生成**: Web Worker (批量数据生成)
 
 ## 项目结构
 
@@ -89,12 +102,13 @@
 │   │   ├── background.ts  # 后台 Service Worker
 │   │   └── content.ts     # 网页注入脚本
 │   ├── pages/             # 各功能模块的页面组件
+│   ├── workers/           # Web Worker (数据生成等耗时任务)
 │   ├── providers/         # 全局状态提供者 (Router, Theme 等)
 │   ├── hooks/             # 自定义 React Hooks
 │   ├── utils/             # 工具函数与服务抽象
 │   ├── types/             # TypeScript 类型声明
-│   └── lib/               # 通用工具函数 (cn, utils 等)
-├── public/                # 静态资源 (图标、manifest 资源等)
+│   └── lib/               # 通用工具函数与生成器库 (cn, utils, generators 等)
+├── public/                # 静态资源 (图标、_locales 本地化资源等)
 ├── wxt.config.ts          # WXT 框架核心配置
 └── package.json           # 项目元数据与依赖管理
 ```
@@ -141,7 +155,6 @@
 - `sidePanel`: 支持在浏览器侧边栏中运行.
 - `clipboardWrite`: 提供一键复制功能.
 - `contextMenus`: 注册右键菜单，支持快捷操作.
-- `alarms`: 管理后台定时任务（如清理后自动刷新）.
 
 ## 浏览器支持
 

docs/VISUAL_STYLE_GUIDE.md

@@ -0,0 +1,871 @@
+# Testing Tools — 视觉规范文档
+
+> **版本**: 1.0.0  
+> **日期**: 2026-05-29  
+> **适用范围**: 所有新页面、新组件、UI 修改  
+> **设计系统**: 基于 [shadcn/ui](https://ui.shadcn.com/) + Tailwind CSS
+
+---
+
+## 目录
+
+1. [设计原则](#1-设计原则)
+2. [色彩系统](#2-色彩系统)
+3. [排版规范](#3-排版规范)
+4. [间距与布局](#4-间距与布局)
+5. [圆角与阴影](#5-圆角与阴影)
+6. [组件规范](#6-组件规范)
+7. [交互与动效](#7-交互与动效)
+8. [暗色模式](#8-暗色模式)
+9. [工具色彩标识](#9-工具色彩标识)
+10. [代码规范](#10-代码规范)
+11. [反模式清单](#11-反模式清单)
+
+---
+
+## 1. 设计原则
+
+### 1.1 核心定位
+
+Testing Tools 是一款**浏览器扩展开发者工具集**，视觉风格遵循：
+
+- **专业克制** — 低饱和度色彩，避免视觉噪音
+- **信息密度优先** — 紧凑布局，在 400×600px 的 popup 空间内高效展示
+- **开发者友好** — 等宽字体用于代码/数据，清晰的信息层级
+- **一致性至上** — 所有页面、组件遵循同一套视觉语言
+
+### 1.2 设计关键词
+
+```
+简洁 · 现代 · 功能导向 · 低对比度 · 微圆角 · 微妙阴影
+```
+
+### 1.3 与 shadcn/ui 的关系
+
+本项目以 shadcn/ui 为底座，所有基础组件（Button、Input、Select 等）均来自或对齐 shadcn/ui 的默认样式。业务组件在此基础上扩展，**不得破坏底层设计语言的统一性**。
+
+---
+
+## 2. 色彩系统
+
+### 2.1 CSS 变量定义
+
+所有色彩通过 CSS 自定义属性（HSL 格式）管理，定义于 `src/index.css`：
+
+#### 亮色模式 (`:root`)
+
+| 变量名                     | HSL 值              | 用途          | 近似色    |
+| -------------------------- | ------------------- | ------------- | --------- |
+| `--background`             | `0 0% 100%`         | 页面背景      | `#ffffff` |
+| `--foreground`             | `222.2 84% 4.9%`    | 主文字        | `#020617` |
+| `--card`                   | `0 0% 100%`         | 卡片背景      | `#ffffff` |
+| `--card-foreground`        | `222.2 84% 4.9%`    | 卡片文字      | `#020617` |
+| `--popover`                | `0 0% 100%`         | 浮层背景      | `#ffffff` |
+| `--popover-foreground`     | `222.2 84% 4.9%`    | 浮层文字      | `#020617` |
+| `--primary`                | `222.2 47.4% 11.2%` | 主按钮/强调   | `#0f172a` |
+| `--primary-foreground`     | `210 40% 98%`       | 主按钮文字    | `#f8fafc` |
+| `--secondary`              | `210 40% 96.1%`     | 次级背景      | `#f1f5f9` |
+| `--secondary-foreground`   | `222.2 47.4% 11.2%` | 次级文字      | `#0f172a` |
+| `--muted`                  | `210 40% 96.1%`     | 静音/禁用背景 | `#f1f5f9` |
+| `--muted-foreground`       | `215.4 16.3% 46.9%` | 次要文字      | `#64748b` |
+| `--accent`                 | `210 40% 96.1%`     | 悬停高亮      | `#f1f5f9` |
+| `--accent-foreground`      | `222.2 47.4% 11.2%` | 悬停文字      | `#0f172a` |
+| `--destructive`            | `0 84.2% 60.2%`     | 错误/删除     | `#ef4444` |
+| `--destructive-foreground` | `210 40% 98%`       | 错误文字      | `#f8fafc` |
+| `--border`                 | `214.3 31.8% 91.4%` | 边框          | `#e2e8f0` |
+| `--input`                  | `214.3 31.8% 91.4%` | 输入框边框    | `#e2e8f0` |
+| `--ring`                   | `222.2 84% 4.9%`    | 焦点环        | `#020617` |
+| `--radius`                 | `0.5rem`            | 全局圆角      | `8px`     |
+
+#### 暗色模式 (`.dark`)
+
+暗色模式下所有变量自动反转，保持对比度关系：
+
+| 变量名                 | HSL 值              | 近似色    |
+| ---------------------- | ------------------- | --------- |
+| `--background`         | `222.2 84% 4.9%`    | `#020617` |
+| `--foreground`         | `210 40% 98%`       | `#f8fafc` |
+| `--primary`            | `210 40% 98%`       | `#f8fafc` |
+| `--primary-foreground` | `222.2 47.4% 11.2%` | `#0f172a` |
+| `--secondary`          | `217.2 32.6% 17.5%` | `#1e293b` |
+| `--muted`              | `217.2 32.6% 17.5%` | `#1e293b` |
+| `--border`             | `217.2 32.6% 17.5%` | `#1e293b` |
+
+### 2.2 使用规范
+
+```tsx
+// ✅ 正确：使用 CSS 变量
+<div className="bg-background text-foreground border-border">
+
+// ✅ 正确：使用语义化色彩名
+<Button className="bg-primary text-primary-foreground">
+<span className="text-muted-foreground">
+
+// ❌ 错误：硬编码颜色值
+<div className="bg-white text-black">
+<div className="bg-[#f1f5f9]">
+```
+
+### 2.3 语义化色彩使用场景
+
+| 色彩                       | 场景                             |
+| -------------------------- | -------------------------------- |
+| `background`               | 页面根背景                       |
+| `foreground`               | 主标题、正文                     |
+| `muted-foreground`         | 描述文字、占位符、次级标签       |
+| `border`                   | 卡片边框、分割线、输入框边框     |
+| `card` + `card-foreground` | 卡片容器及其内容                 |
+| `primary`                  | 主按钮、选中状态、关键操作       |
+| `secondary`                | 次级按钮、工具栏背景、标签页背景 |
+| `destructive`              | 错误提示、删除操作、验证失败     |
+| `accent`                   | 悬停背景、下拉选中项             |
+
+---
+
+## 3. 排版规范
+
+### 3.1 字体栈
+
+项目使用系统默认字体栈（Tailwind 默认），**不引入自定义字体**。
+
+```css
+/* Tailwind 默认 sans-serif */
+font-family:
+  ui-sans-serif,
+  system-ui,
+  -apple-system,
+  BlinkMacSystemFont,
+  'Segoe UI',
+  Roboto,
+  'Helvetica Neue',
+  Arial,
+  sans-serif;
+
+/* 等宽字体用于代码/数据 */
+font-family:
+  ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace;
+```
+
+### 3.2 字号层级
+
+| 层级      | 类名                                             | 大小 | 字重    | 用途                   |
+| --------- | ------------------------------------------------ | ---- | ------- | ---------------------- |
+| 页面标题  | `text-base font-bold`                            | 16px | 700     | 页面主标题（极少使用） |
+| 卡片标题  | `text-sm font-bold tracking-tight`               | 14px | 700     | 卡片/区块标题          |
+| 正文      | `text-sm`                                        | 14px | 400     | 普通正文               |
+| 次级文字  | `text-xs`                                        | 12px | 400/500 | 描述、标签             |
+| 微标签    | `text-[10px] font-bold uppercase tracking-wider` | 10px | 700     | 区域标签、分类标题     |
+| 数据/代码 | `font-mono text-sm`                              | 14px | 400     | 时间戳、JSON、代码     |
+
+### 3.3 排版模式
+
+```tsx
+// 区域标签（Section Label）— 最常用
+<span className="text-[10px] font-bold text-muted-foreground/90 uppercase tracking-wider">
+  输出结果
+</span>
+
+// 卡片标题
+<h4 className="font-bold text-sm tracking-tight text-foreground leading-snug">
+  标题文字
+</h4>
+
+// 描述文字
+<p className="text-[11px] font-medium text-muted-foreground/90 leading-normal">
+  描述内容
+</p>
+
+// 数据展示
+<span className="font-mono font-bold text-foreground text-sm tracking-tight tabular-nums">
+  1716950400000
+</span>
+```
+
+### 3.4 行高与字间距
+
+| 属性              | 值       | 场景               |
+| ----------------- | -------- | ------------------ |
+| `leading-none`    | 1        | 单行数据、紧凑布局 |
+| `leading-snug`    | 1.375    | 标题、短文本       |
+| `leading-relaxed` | 1.625    | 长文本、代码块     |
+| `tracking-tight`  | -0.025em | 标题、数据         |
+| `tracking-wider`  | 0.05em   | 大写标签           |
+
+---
+
+## 4. 间距与布局
+
+### 4.1 容器尺寸
+
+```tsx
+// Popup 模式（默认）
+<div className="w-[400px] max-w-[400px] min-w-[400px] h-[600px] min-h-[600px]">
+
+// Tab 模式（全屏自适应）
+<div className="sm:w-screen sm:max-w-none sm:min-w-0 sm:h-screen sm:min-h-0">
+```
+
+### 4.2 间距节奏
+
+| Token           | 值          | 使用场景           |
+| --------------- | ----------- | ------------------ |
+| `p-3` / `p-3.5` | 12px / 14px | 页面内边距（紧凑） |
+| `p-4`           | 16px        | 标准页面内边距     |
+| `p-5`           | 20px        | 卡片内部填充       |
+| `gap-2`         | 8px         | 紧凑元素间距       |
+| `gap-3`         | 12px        | 标准元素间距       |
+| `gap-4`         | 16px        | 区块间距           |
+| `gap-6`         | 24px        | 大区块间距         |
+
+### 4.3 布局模式
+
+#### 页面布局
+
+```tsx
+// 标准页面结构
+<div className="p-4 w-full flex flex-col space-y-4 min-h-[500px] select-none">{/* 页面内容 */}</div>
+```
+
+#### 卡片布局
+
+```tsx
+// 标准卡片
+<div className="p-5 rounded-xl border border-border bg-card text-card-foreground shadow-sm">
+  {/* 卡片内容 */}
+</div>
+
+// 可聚焦卡片（含焦点环）
+<div className="border border-border rounded-xl bg-card ... focus-within:ring-1 focus-within:ring-ring focus-within:border-ring">
+```
+
+#### 双栏网格
+
+```tsx
+// 响应式双栏
+<div className="grid grid-cols-1 md:grid-cols-2 gap-4 items-stretch">
+```
+
+#### 工具卡片网格（Dashboard）
+
+```tsx
+// Dashboard 紧凑网格
+<div className="grid grid-cols-3 sm:grid-cols-4 md:grid-cols-5 lg:grid-cols-6 gap-2">
+```
+
+---
+
+## 5. 圆角与阴影
+
+### 5.1 圆角体系
+
+| Token          | 值     | 使用元素               |
+| -------------- | ------ | ---------------------- |
+| `rounded-sm`   | 2px    | Checkbox、小标签       |
+| `rounded-md`   | 6px    | 按钮、输入框、Select   |
+| `rounded-lg`   | 8px    | 搜索框、小卡片         |
+| `rounded-xl`   | 12px   | 大卡片、面板、图标容器 |
+| `rounded-full` | 9999px | 标签、Avatar           |
+
+### 5.2 阴影体系
+
+| 级别 | 类名                  | 用途                   |
+| ---- | --------------------- | ---------------------- |
+| 无   | —                     | 静态元素               |
+| 低   | `shadow-sm`           | 卡片、输入框、按钮     |
+| 中   | `shadow-lg`           | 下拉菜单、浮层、Dialog |
+| 动态 | 自定义 `shadow-[...]` | 卡片悬停时的彩色阴影   |
+
+### 5.3 彩色阴影规范（工具卡片专用）
+
+```tsx
+// 工具卡片悬停阴影 — 必须使用 rgba 格式配合 CSS 变量
+className="hover:shadow-[0_8px_24px_-8px_rgba(var(--tool-color),0.14)]
+           dark:hover:shadow-[0_8px_30px_-10px_rgba(var(--tool-color),0.25)]"
+```
+
+---
+
+## 6. 组件规范
+
+### 6.1 Button
+
+来源：`src/components/ui/button.tsx`
+
+#### 变体
+
+| 变体          | 类名                                         | 场景               |
+| ------------- | -------------------------------------------- | ------------------ |
+| `default`     | `bg-primary text-primary-foreground`         | 主操作             |
+| `destructive` | `bg-destructive text-destructive-foreground` | 删除、危险操作     |
+| `outline`     | `border border-input bg-background`          | 次级操作、取消     |
+| `secondary`   | `bg-secondary text-secondary-foreground`     | 次要操作           |
+| `ghost`       | 仅悬停背景                                   | 图标按钮、低优先级 |
+| `link`        | 下划线文字                                   | 跳转链接           |
+
+#### 尺寸
+
+| 尺寸      | 高度    | 内边距      | 场景     |
+| --------- | ------- | ----------- | -------- |
+| `default` | 40px    | `px-4 py-2` | 标准按钮 |
+| `sm`      | 36px    | `px-3`      | 紧凑按钮 |
+| `lg`      | 44px    | `px-8`      | 突出按钮 |
+| `icon`    | 40×40px | —           | 图标按钮 |
+
+#### 使用示例
+
+```tsx
+// 主操作
+<Button>确认</Button>
+
+// 图标按钮
+<Button variant="ghost" size="icon">
+  <Copy className="h-4 w-4" />
+</Button>
+
+// 危险操作
+<Button variant="destructive" size="sm">删除</Button>
+```
+
+### 6.2 Input
+
+来源：`src/components/ui/input.tsx`
+
+```tsx
+// 标准输入框
+<Input
+  className="font-mono font-semibold h-10 shadow-sm placeholder:text-muted-foreground/60 focus:bg-background"
+/>
+
+// 错误状态
+<Input
+  className="border-destructive focus-visible:ring-destructive"
+/>
+```
+
+**规范要点**：
+
+- 高度统一为 `h-10`（40px）
+- 等宽字体用于数据输入
+- 占位符使用 `text-muted-foreground/60`
+- 错误时边框变红并调整焦点环
+
+### 6.3 SwitchButtonGroup
+
+来源：`src/components/ui/switch.tsx`
+
+```tsx
+// 分段控制器
+<SwitchButtonGroup
+  value={mode}
+  options={[
+    { value: 'ts2dt', label: '转日期' },
+    { value: 'dt2ts', label: '转时间戳' },
+  ]}
+  onChange={setMode}
+  size="small"
+/>
+```
+
+**规范要点**：
+
+- 容器：`rounded-lg bg-muted p-1`
+- 选中项：`bg-background text-foreground shadow-sm font-semibold`
+- 未选中项：`hover:bg-background/50 hover:text-foreground/80`
+- 尺寸：`small`（32px）用于工具页，`medium`（36px）标准
+
+### 6.4 Card（工具卡片）
+
+来源：`src/pages/Dashboard/ToolCard.tsx`
+
+```tsx
+// 标准工具卡片结构
+<div className="group relative rounded-xl border border-border/70 bg-card p-4 h-auto flex flex-col gap-3 shadow-sm">
+  {/* 上半部分：图标 + 标题 + 箭头 */}
+  <div className="flex items-center justify-between">
+    <div className="flex gap-3 items-center">
+      {/* 图标容器 */}
+      <div className="flex items-center justify-center w-10 h-10 rounded-xl bg-[rgba(var(--tool-color),0.08)] text-[rgb(var(--tool-color))]">
+        <Icon className="h-5 w-5" />
+      </div>
+      {/* 文字 */}
+      <div>
+        <h4 className="font-bold text-sm">标题</h4>
+        <p className="text-[11px] text-muted-foreground/90">描述</p>
+      </div>
+    </div>
+    <ChevronRight className="h-4 w-4" />
+  </div>
+  {/* 下半部分：预览区（可选） */}
+  <div className="mt-1 pt-3 border-t border-dashed border-border/80">{snapshot}</div>
+</div>
+```
+
+### 6.5 TextInputArea
+
+来源：`src/components/TextInputArea.tsx`
+
+```tsx
+// 多行文本输入区
+<TextInputArea
+  value={input}
+  onChange={setInput}
+  placeholder="输入内容..."
+  showCount={true}
+  showClear={true}
+  allowCopy={true}
+  minRows={6}
+  maxRows={12}
+/>
+```
+
+**规范要点**：
+
+- 外容器：`rounded-md border border-input bg-background shadow-sm`
+- 焦点状态：`focus-within:ring-1 focus-within:ring-ring`
+- 错误状态：`border-destructive focus-within:ring-destructive`
+- 底部工具栏：`h-10 bg-muted/30 border-t border-border/50`
+- 字体：`font-mono text-sm`
+
+### 6.6 Dialog
+
+来源：`src/components/ui/dialog.tsx`
+
+```tsx
+// 对话框内容
+<DialogContent className="sm:rounded-lg">
+  <DialogHeader>
+    <DialogTitle>标题</DialogTitle>
+    <DialogDescription>描述文字</DialogDescription>
+  </DialogHeader>
+  {/* 内容 */}
+  <DialogFooter>
+    <Button variant="outline">取消</Button>
+    <Button>确认</Button>
+  </DialogFooter>
+</DialogContent>
+```
+
+### 6.7 Select
+
+来源：`src/components/ui/select.tsx`
+
+```tsx
+<Select>
+  <SelectTrigger className="h-9 shadow-sm bg-background">
+    <SelectValue />
+  </SelectTrigger>
+  <SelectContent className="max-h-64">
+    <SelectItem className="text-xs font-semibold focus:bg-accent cursor-pointer">选项</SelectItem>
+  </SelectContent>
+</Select>
+```
+
+### 6.8 Checkbox
+
+来源：`src/components/ui/checkbox.tsx`
+
+```tsx
+// 标准复选框
+<Checkbox className="h-4 w-4 rounded-sm border-primary data-[state=checked]:bg-primary" />
+
+// 小型复选框（工具栏内）
+<Checkbox className="h-3.5 w-3.5 rounded border-input data-[state=checked]:bg-primary shadow-sm" />
+```
+
+### 6.9 Badge
+
+来源：`src/components/ui/badge.tsx`
+
+| 变体          | 场景               |
+| ------------- | ------------------ |
+| `default`     | 状态标签、分类     |
+| `secondary`   | 次要标签           |
+| `destructive` | 错误标签           |
+| `outline`     | 可点击标签、筛选器 |
+
+### 6.10 CopyButton
+
+来源：`src/components/CopyButton.tsx`
+
+```tsx
+// 标准复制按钮
+<CopyButton text={content} />
+
+// 小型复制按钮
+<CopyButton text={content} size="sm" className="h-7 w-7 rounded-md border" />
+```
+
+**规范要点**：
+
+- 默认 `variant="ghost" size="icon"`
+- 复制成功后变为绿色背景 + 对勾图标
+- 使用 `sonner` toast 提示复制结果
+
+---
+
+## 7. 交互与动效
+
+### 7.1 过渡规范
+
+| 属性                | 值         | 场景                          |
+| ------------------- | ---------- | ----------------------------- |
+| `transition-colors` | 150ms ease | 色彩变化（悬停、焦点）        |
+| `transition-all`    | 150ms ease | 综合变化（SwitchButtonGroup） |
+| `duration-200`      | 200ms      | 复制按钮状态切换              |
+
+### 7.2 焦点状态
+
+所有可交互元素必须有可见的焦点指示器：
+
+```tsx
+// 标准焦点环
+focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2
+
+// 紧凑焦点环（图标按钮）
+focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring
+
+// 输入框焦点
+focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2
+```
+
+### 7.3 悬停状态
+
+```tsx
+// 按钮悬停
+hover:bg-accent hover:text-accent-foreground
+
+// 卡片悬停
+hover:bg-muted/30 hover:border-[rgba(var(--tool-color),0.45)]
+
+// 链接/文字悬停
+hover:text-foreground hover:underline
+```
+
+### 7.4 动画规范
+
+使用 `tailwindcss-animate` 提供的动画：
+
+```tsx
+// 淡入
+animate-in fade-in duration-150
+
+// 淡入 + 缩放（SwitchButtonGroup 选中项）
+animate-in fade-in-50 zoom-in-95 duration-150
+
+// 从顶部滑入（下拉菜单）
+animate-in fade-in slide-in-from-top-2 duration-150
+
+// 错误提示出现
+animate-in fade-in slide-in-from-top-1 duration-150
+
+// 骨架屏脉冲
+animate-pulse
+```
+
+### 7.5 禁用状态
+
+```tsx
+// 统一禁用样式
+disabled:pointer-events-none disabled:opacity-50
+```
+
+---
+
+## 8. 暗色模式
+
+### 8.1 实现方式
+
+通过 `darkMode: 'class'`（Tailwind 配置）+ `.dark` 类切换：
+
+```tsx
+// ThemeModeProvider 自动处理
+document.documentElement.classList.toggle('dark', resolvedMode === 'dark');
+```
+
+### 8.2 暗色模式下的特殊处理
+
+```tsx
+// 彩色阴影增强（暗色模式下阴影需要更高透明度）
+shadow-[0_8px_24px_-8px_rgba(var(--tool-color),0.14)]
+dark:shadow-[0_8px_30px_-10px_rgba(var(--tool-color),0.25)]
+
+// 图标容器背景增强
+bg-[rgba(var(--tool-color),0.08)]
+dark:bg-[rgba(var(--tool-color),0.12)]
+
+// 成功状态文字调整
+text-emerald-600 dark:text-emerald-400
+```
+
+### 8.3 暗色模式色彩映射原则
+
+| 亮色             | 暗色             | 说明                            |
+| ---------------- | ---------------- | ------------------------------- |
+| 纯白背景         | 深蓝黑背景       | 避免纯黑 `#000`，使用 `#020617` |
+| 浅灰背景         | 深灰背景         | 保持层次关系                    |
+| 深文字           | 浅文字           | 反转对比度                      |
+| 彩色阴影低透明度 | 彩色阴影高透明度 | 暗色需要更强视觉反馈            |
+
+---
+
+## 9. 工具色彩标识
+
+### 9.1 色板定义
+
+每个工具分配一个主题色，定义于 `src/config/features.tsx`：
+
+```ts
+const PALETTE_COLORS: Record<PaletteColorKey, string> = {
+  primary: '13, 148, 136', // teal (#0d9488)
+  success: '22, 163, 74', // green (#16a34a)
+  warning: '217, 119, 6', // amber (#d97706)
+  error: '220, 38, 38', // red (#dc2626)
+  secondary: '147, 51, 232', // purple (#9333e8)
+  info: '37, 99, 235', // blue (#2563eb)
+};
+```
+
+### 9.2 工具色彩分配
+
+| 工具        | 色彩键      | 色值   |
+| ----------- | ----------- | ------ |
+| 时间戳转换  | `primary`   | Teal   |
+| 存储清理    | `warning`   | Amber  |
+| 二维码工具  | `success`   | Green  |
+| 文本统计    | `secondary` | Purple |
+| JWT 解析    | `info`      | Blue   |
+| JSON 对比   | `primary`   | Teal   |
+| Base64 转换 | `info`      | Blue   |
+| 右键还原    | `success`   | Green  |
+
+### 9.3 工具色彩使用规范
+
+```tsx
+// 1. 通过 style 注入 CSS 变量
+<div style={{ ['--tool-color' as string]: rgbValues }}>
+
+// 2. 图标容器背景（低透明度）
+bg-[rgba(var(--tool-color),0.08)]
+dark:bg-[rgba(var(--tool-color),0.12)]
+
+// 3. 图标颜色
+ text-[rgb(var(--tool-color))]
+
+// 4. 悬停边框
+hover:border-[rgba(var(--tool-color),0.45)]
+
+// 5. 悬停阴影
+hover:shadow-[0_8px_24px_-8px_rgba(var(--tool-color),0.14)]
+
+// 6. 箭头悬停色
+group-hover:text-[rgb(var(--tool-color))]
+```
+
+**注意**：工具色彩仅用于**标识和装饰**，不得用于功能性色彩（如成功/错误状态）。
+
+---
+
+## 10. 代码规范
+
+### 10.1 Tailwind 类名组织顺序
+
+使用 `cn()` 工具函数（`clsx` + `tailwind-merge`）组合类名，按以下顺序排列：
+
+```tsx
+className={cn(
+  // 1. 布局（display, position, flex, grid）
+  'flex items-center justify-between',
+  // 2. 尺寸（width, height, padding, margin）
+  'w-full h-10 px-4',
+  // 3. 外观（background, border, shadow, rounded）
+  'rounded-md border border-input bg-background shadow-sm',
+  // 4. 文字（color, font, text-align）
+  'text-sm font-medium text-foreground',
+  // 5. 交互（hover, focus, disabled, cursor）
+  'hover:bg-accent focus-visible:ring-2 disabled:opacity-50',
+  // 6. 动画（transition, animate）
+  'transition-colors duration-150',
+  // 7. 条件类
+  isActive && 'bg-primary text-primary-foreground',
+  // 8. 外部传入
+  className,
+)}
+```
+
+### 10.2 颜色使用检查清单
+
+- [ ] 所有颜色使用 CSS 变量（`bg-background` 而非 `bg-white`）
+- [ ] 边框使用 `border-border` 及其透明度变体
+- [ ] 文字层级使用 `foreground` → `muted-foreground` → `muted-foreground/60`
+- [ ] 错误状态使用 `destructive` 系列
+- [ ] 工具色彩仅用于装饰性元素
+
+### 10.3 组件文件组织
+
+```
+src/
+├── components/ui/          # shadcn 基础组件（只读，不修改）
+├── components/             # 业务组件
+│   ├── CopyButton.tsx
+│   ├── SwitchButtonGroup.tsx
+│   ├── TextInputArea.tsx
+│   └── ...
+├── pages/                  # 页面组件
+│   ├── <ToolName>/
+│   │   ├── index.tsx       # 页面入口
+│   │   ├── use<ToolName>.ts # 业务逻辑 Hook
+│   │   └── components/     # 页面私有组件
+│   └── ...
+└── providers/              # Context Providers
+```
+
+### 10.4 新增页面模板
+
+```tsx
+// src/pages/NewTool/index.tsx
+import SwitchButtonGroup from '@/components/SwitchButtonGroup';
+import { useI18n } from '@/utils/chromeI18n';
+import { cn } from '@/lib/utils';
+
+export default function Index() {
+  const { t } = useI18n('newTool');
+
+  return (
+    <div className="p-4 w-full flex flex-col space-y-4 min-h-[500px] select-none">
+      {/* 页面内容 */}
+      <div className="p-5 rounded-xl border border-border bg-card text-card-foreground shadow-sm">
+        <h4 className="font-bold text-sm tracking-tight">{t('newTool:title')}</h4>
+      </div>
+    </div>
+  );
+}
+```
+
+---
+
+## 11. 反模式清单
+
+以下模式**禁止**在项目中使用：
+
+### 11.1 色彩反模式
+
+```tsx
+// ❌ 硬编码颜色
+<div className="bg-white text-black">
+<div className="bg-gray-100">
+<div className="text-gray-500">
+
+// ❌ 使用非语义化 Tailwind 颜色
+<div className="bg-slate-50">
+<div className="text-zinc-400">
+
+// ✅ 使用 CSS 变量
+<div className="bg-background text-foreground">
+<div className="bg-muted text-muted-foreground">
+```
+
+### 11.2 布局反模式
+
+```tsx
+// ❌ 固定高度导致内容截断
+<div className="h-[200px]">
+
+// ✅ 使用 min-height 或自适应
+<div className="min-h-[200px]">
+<div className="h-auto">
+
+// ❌ 使用 margin 做组件间距
+<div className="mb-4">
+
+// ✅ 使用 gap
+<div className="flex flex-col gap-4">
+```
+
+### 11.3 组件反模式
+
+```tsx
+// ❌ 修改 shadcn/ui 基础组件样式
+// 如需修改，通过 className 覆盖或创建包装组件
+
+// ❌ 内联样式用于颜色（工具色彩除外）
+<div style={{ backgroundColor: '#f1f5f9' }}>
+
+// ❌ 混合使用不同圆角体系
+<Button className="rounded-lg">  // Button 应为 rounded-md
+
+// ❌ 忽略焦点状态
+<button className="...">  // 缺少 focus-visible 样式
+```
+
+### 11.4 暗色模式反模式
+
+```tsx
+// ❌ 仅适配部分元素
+<div className="bg-white text-black dark:bg-gray-900 dark:text-white">
+
+// ✅ 使用 CSS 变量自动适配
+<div className="bg-background text-foreground">
+
+// ❌ 暗色模式下使用不合适的透明度
+<div className="bg-black/5 dark:bg-white/5">  // 对比度不足
+
+// ✅ 使用语义化变量
+<div className="bg-muted">
+```
+
+---
+
+## 12. 附录
+
+### 12.1 常用类名速查
+
+```
+// 页面容器
+p-4 w-full flex flex-col space-y-4 min-h-[500px] select-none
+
+// 标准卡片
+p-5 rounded-xl border border-border bg-card text-card-foreground shadow-sm
+
+// 工具栏
+flex h-10 items-center justify-between px-1.5 bg-secondary/40 rounded-xl border border-border/60
+
+// 区域标签
+text-[10px] font-bold text-muted-foreground/90 uppercase tracking-wider
+
+// 数据展示
+font-mono font-semibold text-foreground text-sm
+
+// 错误提示
+text-xs font-medium text-destructive
+
+// 空状态
+p-8 rounded-xl bg-muted/30 border border-dashed border-border/80 text-center
+
+// 图标按钮容器
+flex h-8 w-8 items-center justify-center rounded-md border border-input bg-background shadow-sm
+
+// 焦点环
+focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2
+```
+
+### 12.2 相关文件
+
+| 文件                                  | 说明                    |
+| ------------------------------------- | ----------------------- |
+| `src/index.css`                       | CSS 变量定义、全局样式  |
+| `tailwind.config.js`                  | Tailwind 配置、色彩映射 |
+| `src/lib/utils.ts`                    | `cn()` 工具函数         |
+| `src/components/ui/*.tsx`             | shadcn/ui 基础组件      |
+| `src/config/features.tsx`             | 工具配置、色彩分配      |
+| `src/providers/ThemeModeProvider.tsx` | 主题模式管理            |
+
+### 12.3 参考资源
+
+- [shadcn/ui 文档](https://ui.shadcn.com/docs)
+- [Tailwind CSS 文档](https://tailwindcss.com/docs)
+- [Radix UI 文档](https://www.radix-ui.com/)
+- [Lucide Icons](https://lucide.dev/)
+
+---
+
+_本文档随项目迭代更新。新增组件或修改视觉风格时，请同步更新此文档。_

docs/test-data-generator/README.md

@@ -0,0 +1,31 @@
+# 测试数据生成器 - 功能设计文档
+
+> 版本: v1.0
+> 创建时间: 2024-01-20
+> 状态: 已实现（见 `src/pages/TestDataGenerator/`、`src/lib/generators/`、`src/workers/generator.worker.ts`）
+
+## 产品定位
+
+**轻量级可视化测试数据生成器**
+
+- 纯前端工具，无需后端
+- 可视化配置，无需编码
+- 本地生成，数据安全
+
+## 目录
+
+- [核心功能](./core-features.md)
+- [生成器库](./generators.md)
+- [规则管理](./rule-management.md)
+- [界面设计](./ui-design.md)
+- [技术实现](./technical-implementation.md)
+
+## 当前实现入口
+
+- 页面入口：`src/pages/TestDataGenerator/index.tsx`
+- Worker：`src/workers/generator.worker.ts`
+- 生成器库：`src/lib/generators/`
+- 规则存储：`src/utils/ruleStorage.ts`
+- 导出工具：`src/utils/dataExporter.ts`
+
+实现约束与任务完成状态记录在 [TASKS.md](./TASKS.md)。

docs/test-data-generator/TASKS.md

@@ -0,0 +1,384 @@
+# 测试数据生成器 - 实现任务列表
+
+> 创建时间: 2026-06-06
+> 状态: ✅ 已完成
+
+## 总体进度
+
+| 子功能                     | 状态      | 预估工时  |
+| -------------------------- | --------- | --------- |
+| 1. 类型定义与项目配置      | ✅ 已完成 | 0.5h      |
+| 2. 生成器库                | ✅ 已完成 | 4h        |
+| 3. Web Worker 数据生成引擎 | ✅ 已完成 | 2h        |
+| 4. 规则存储与管理          | ✅ 已完成 | 2h        |
+| 5. 数据导出功能            | ✅ 已完成 | 1h        |
+| 6. UI 组件开发             | ✅ 已完成 | 6h        |
+| 7. 页面集成与注册          | ✅ 已完成 | 1h        |
+| 8. 测试与优化              | ✅ 已完成 | 2h        |
+| **总计**                   |           | **18.5h** |
+
+---
+
+## 1. 类型定义与项目配置
+
+**目标**: 创建所有必要的类型定义文件，配置项目注册新功能
+
+### 任务清单
+
+- [x] 1.1 创建 `src/types/testDataGenerator.ts` 类型定义文件
+  - [x] 定义 `FieldConfig` 接口
+  - [x] 定义 `DataRule` 接口
+  - [x] 定义 `GeneratorDefinition` 接口
+  - [x] 定义 `GeneratorParam` 接口
+  - [x] 定义 `GenerateResult` 接口
+  - [x] 定义 `ExportFile` 接口
+
+- [x] 1.2 更新 `src/types/storage.d.ts`
+  - [x] 在 `PageType` 中添加 `'testDataGenerator'`
+  - [x] 在 `StorageSchema` 中添加测试数据生成器相关配置（如需要）
+
+- [x] 1.3 更新 `src/config/features.tsx`
+  - [x] 导入 TestDataGenerator 页面组件
+  - [x] 添加新功能配置到 `FEATURES` 数组
+  - [x] 选择合适的图标（如 `Database` 或 `FileSpreadsheet`）
+
+- [x] 1.4 更新国际化配置
+  - [x] 添加 `testDataGenerator_title` 翻译
+  - [x] 添加 `testDataGenerator_description` 翻译
+
+---
+
+## 2. 生成器库
+
+**目标**: 实现 21 个数据生成器，支持多种生成策略
+
+### 任务清单
+
+#### 2.1 生成器基础框架
+
+- [x] 2.1.1 创建 `src/lib/generators/types.ts`
+  - [x] 定义生成器内部类型（与 `testDataGenerator.ts` 分离）
+
+- [x] 2.1.2 创建 `src/lib/generators/index.ts`
+  - [x] 导出所有生成器
+  - [x] 导出 `generatorCategories` 配置
+
+#### 2.2 个人信息生成器 (6个)
+
+- [x] 2.2.1 创建 `src/lib/generators/personal.ts`
+  - [x] 实现 `chineseName` 生成器
+    - [x] `generate()` 方法
+    - [x] `generateAtIndex()` 方法
+  - [x] 实现 `email` 生成器
+    - [x] `generate()` 方法
+    - [x] `generateAtIndex()` 方法
+  - [x] 实现 `chinesePhone` 生成器
+    - [x] `generate()` 方法
+    - [x] `generateAtIndex()` 方法
+  - [x] 实现 `idCard` 生成器
+    - [x] `generate()` 方法
+    - [x] `generateAtIndex()` 方法
+  - [x] 实现 `chineseAddress` 生成器
+    - [x] `generate()` 方法
+    - [x] `generateAtIndex()` 方法
+  - [x] 实现 `age` 生成器
+    - [x] `generate()` 方法（支持 realistic/uniform/demographic 策略）
+    - [x] `generateAtIndex()` 方法
+    - [x] 实现 `normalRandom()` 辅助函数
+    - [x] 实现 `demographicRandom()` 辅助函数
+
+#### 2.3 业务数据生成器 (8个)
+
+- [x] 2.3.1 创建 `src/lib/generators/business.ts`
+  - [x] 实现 `orderId` 生成器
+  - [x] 实现 `price` 生成器
+    - [x] 实现 `generatePsychologicalPrice()` 辅助函数
+    - [x] 实现 `generateRealisticPrice()` 辅助函数
+  - [x] 实现 `date` 生成器
+    - [x] 实现 `formatDate()` 辅助函数
+  - [x] 实现 `status` 生成器
+  - [x] 实现 `quantity` 生成器
+    - [x] 实现 `poissonRandom()` 辅助函数
+  - [x] 实现 `rating` 生成器
+    - [x] 实现 `skewedRandom()` 辅助函数
+  - [x] 实现 `discount` 生成器
+    - [x] 实现 `generatePsychologicalDiscount()` 辅助函数
+  - [x] 实现 `stock` 生成器
+    - [x] 实现 `exponentialRandom()` 辅助函数
+
+#### 2.4 技术数据生成器 (3个)
+
+- [x] 2.4.1 创建 `src/lib/generators/technical.ts`
+  - [x] 实现 `uuid` 生成器
+  - [x] 实现 `ipv4` 生成器
+  - [x] 实现 `url` 生成器
+
+#### 2.5 基础类型生成器 (4个)
+
+- [x] 2.5.1 创建 `src/lib/generators/basic.ts`
+  - [x] 实现 `randomInt` 生成器
+  - [x] 实现 `randomFloat` 生成器
+  - [x] 实现 `randomString` 生成器
+  - [x] 实现 `fromList` 生成器
+
+---
+
+## 3. Web Worker 数据生成引擎
+
+**目标**: 实现后台数据生成，支持进度回调和取消
+
+### 任务清单
+
+- [x] 3.1 创建 `src/workers/generator.worker.ts`
+  - [x] 实现 `self.onmessage` 处理器
+  - [x] 验证生成器是否存在
+  - [x] 实现数据生成循环
+  - [x] 实现空值率控制逻辑
+  - [x] 实现唯一性约束逻辑
+    - [x] 小数据量：随机生成 + 重试（100次上限）
+    - [x] 大数据量：索引生成策略
+  - [x] 实现进度回调（每1000条）
+  - [x] 实现完成回调（包含统计数据）
+  - [x] 实现错误回调
+
+- [x] 3.2 创建 `src/pages/TestDataGenerator/hooks/useGenerator.ts`
+  - [x] 实现 Worker 创建和销毁
+  - [x] 实现 `generate()` 方法
+  - [x] 实现 `terminate()` 方法
+  - [x] 管理进度状态
+  - [x] 管理生成结果状态
+
+---
+
+## 4. 规则存储与管理
+
+**目标**: 实现规则的持久化存储和管理功能
+
+### 任务清单
+
+- [x] 4.1 创建 `src/utils/ruleStorage.ts`
+  - [x] 定义 `STORAGE_KEY` 常量
+  - [x] 定义 `MAX_RULES = 20` 常量
+  - [x] 实现 `getAll()` 方法
+  - [x] 实现 `getById()` 方法
+  - [x] 实现 `getCount()` 方法
+  - [x] 实现 `isMaxReached()` 方法
+  - [x] 实现 `save()` 方法（含数量限制检查）
+  - [x] 实现 `update()` 方法
+  - [x] 实现 `delete()` 方法
+  - [x] 实现 `duplicate()` 方法
+  - [x] 实现 `recordUse()` 方法
+  - [x] 实现 `search()` 方法
+  - [x] 实现 `getRecent()` 方法
+  - [x] 实现 `export()` 方法
+  - [x] 实现 `import()` 方法（含格式验证）
+  - [x] 实现 `clear()` 方法
+  - [x] 实现 `validateRule()` 私有方法
+
+---
+
+## 5. 数据导出功能
+
+**目标**: 实现 JSON 和 CSV 格式的数据导出
+
+### 任务清单
+
+- [x] 5.1 创建 `src/utils/dataExporter.ts`
+  - [x] 实现 `toJSON()` 静态方法
+  - [x] 实现 `toCSV()` 静态方法
+  - [x] 实现 `escapeCSV()` 私有方法
+  - [x] 实现 `exportByFormat()` 静态方法
+  - [x] 实现 `toMultipleFiles()` 静态方法
+  - [x] 实现 `toSingleFile()` 静态方法
+  - [x] 实现 `getMimeType()` 私有方法
+  - [x] 实现 `download()` 静态方法
+  - [x] 实现 `downloadMultiple()` 静态方法
+
+---
+
+## 6. UI 组件开发
+
+**目标**: 实现所有界面组件，遵循视觉规范
+
+### 任务清单
+
+#### 6.1 页面组件
+
+- [x] 6.1.1 创建 `src/pages/TestDataGenerator/index.tsx` 主页面
+  - [x] 实现左右分栏布局（60% / 40%）
+  - [x] 集成所有子组件
+  - [x] 管理页面状态
+
+#### 6.2 字段管理组件
+
+- [x] 6.2.1 创建 `src/pages/TestDataGenerator/components/FieldList.tsx`
+  - [x] 实现字段列表展示
+  - [x] 实现添加字段按钮
+  - [x] 实现字段拖拽排序（可选，使用上移/下移按钮）
+
+- [x] 6.2.2 创建 `src/pages/TestDataGenerator/components/FieldItem.tsx`
+  - [x] 实现单个字段项展示
+  - [x] 实现字段名编辑
+  - [x] 实现生成器切换下拉框
+  - [x] 实现配置按钮
+  - [x] 实现删除按钮
+  - [x] 实现上移/下移按钮
+
+- [x] 6.2.3 创建 `src/pages/TestDataGenerator/components/FieldEditor.tsx`
+  - [x] 实现基础配置区（字段名、描述）
+  - [x] 实现必填/选填切换
+  - [x] 实现空值率配置（仅选填时显示）
+    - [x] 滑块组件
+    - [x] 预设按钮（低/中/高）
+  - [x] 实现唯一性约束开关
+
+#### 6.3 生成器相关组件
+
+- [x] 6.3.1 创建 `src/pages/TestDataGenerator/components/GeneratorSelector.tsx`
+  - [x] 实现分类展示（个人信息/业务数据/技术数据/基础类型）
+  - [x] 实现搜索功能
+  - [x] 实现生成器选择
+
+- [x] 6.3.2 创建 `src/pages/TestDataGenerator/components/GeneratorConfig.tsx`
+  - [x] 实现参数配置表单
+  - [x] 支持不同参数类型（string/number/boolean/select/array）
+  - [x] 实时预览更新
+
+#### 6.4 数据预览组件
+
+- [x] 6.4.1 创建 `src/pages/TestDataGenerator/components/DataPreview.tsx`
+  - [x] 实现 JSON 格式预览
+  - [x] 实现 CSV 格式预览
+  - [x] 实现格式切换按钮
+  - [x] 实现数据分页
+  - [x] 实现复制功能
+
+#### 6.5 生成选项组件
+
+- [x] 6.5.1 创建 `src/pages/TestDataGenerator/components/GenerateOptions.tsx`
+  - [x] 实现生成数量配置（预设 + 自定义）
+  - [x] 实现数据格式选择（JSON/CSV）
+  - [x] 实现默认空值率配置
+
+- [x] 6.5.2 创建 `src/pages/TestDataGenerator/components/GenerateButton.tsx`
+  - [x] 实现生成按钮
+  - [x] 实现加载状态
+  - [x] 实现进度条显示
+
+#### 6.6 导出组件
+
+- [x] 6.6.1 创建 `src/pages/TestDataGenerator/components/ExportPanel.tsx`
+  - [x] 实现导出选项（复制/下载 JSON/下载 CSV）
+  - [x] 实现下载逻辑
+
+#### 6.7 结果展示组件
+
+- [x] 6.7.1 创建 `src/pages/TestDataGenerator/components/ResultPanel.tsx`
+  - [x] 实现成功状态展示
+  - [x] 实现警告状态展示（部分字段失败）
+  - [x] 实现错误状态展示
+  - [x] 实现数据统计展示
+
+#### 6.8 规则管理组件
+
+- [x] 6.8.1 创建 `src/pages/TestDataGenerator/components/RuleManager.tsx`
+  - [x] 实现规则列表展示
+  - [x] 实现搜索功能
+  - [x] 实现加载/编辑/删除/复制按钮
+  - [x] 实现导入/导出功能
+  - [x] 实现规则数量显示（已保存 X/20 条）
+
+---
+
+## 7. 页面集成与注册
+
+**目标**: 将新功能集成到应用中
+
+### 任务清单
+
+- [x] 7.1 更新路由配置
+  - [x] 确保 `RouterProvider` 支持新页面类型
+
+- [x] 7.2 更新功能注册
+  - [x] 验证 `features.tsx` 配置正确
+  - [x] 验证图标显示正常
+
+- [x] 7.3 更新仪表盘
+  - [x] 在 Dashboard 中显示新工具卡片
+
+---
+
+## 8. 测试与优化
+
+**目标**: 确保功能稳定性和性能
+
+### 任务清单
+
+#### 8.1 单元测试
+
+- [x] 8.1.1 创建生成器测试
+  - [x] `src/lib/generators/__tests__/personal.test.ts`
+  - [x] `src/lib/generators/__tests__/business.test.ts`
+  - [x] `src/lib/generators/__tests__/technical.test.ts`
+  - [x] `src/lib/generators/__tests__/basic.test.ts`
+
+- [x] 8.1.2 创建工具函数测试
+  - [x] `src/utils/__tests__/ruleStorage.test.ts`
+  - [x] `src/utils/__tests__/dataExporter.test.ts`
+
+#### 8.2 集成测试
+
+- [x] 8.2.1 创建页面测试
+  - [x] `src/pages/TestDataGenerator/__tests__/TestDataGenerator.test.tsx`
+
+#### 8.3 性能优化
+
+- [x] 8.3.1 验证 Web Worker 性能
+  - [x] 测试 10000+ 条数据生成
+  - [x] 验证 UI 不阻塞
+
+- [x] 8.3.2 验证内存使用
+  - [x] 检查大数据量时的内存占用
+  - [x] 确保无内存泄漏
+
+#### 8.4 代码质量
+
+- [x] 8.4.1 代码审查
+  - [x] 遵循项目代码规范
+  - [x] 遵循视觉规范文档
+
+- [x] 8.4.2 文档更新
+  - [x] 更新 AGENTS.md（如需要）
+
+---
+
+## 依赖关系
+
+```
+1. 类型定义与项目配置
+    ↓
+2. 生成器库
+    ↓
+3. Web Worker 数据生成引擎 (依赖 2)
+    ↓
+4. 规则存储与管理
+    ↓
+5. 数据导出功能
+    ↓
+6. UI 组件开发 (依赖 1, 2, 3, 4, 5)
+    ↓
+7. 页面集成与注册 (依赖 6)
+    ↓
+8. 测试与优化 (依赖 7)
+```
+
+---
+
+## 注意事项
+
+1. **遵循视觉规范**: 所有 UI 组件必须遵循 `docs/VISUAL_STYLE_GUIDE.md`
+2. **使用现有组件**: 优先使用 `src/components/ui/` 中的 shadcn/ui 组件
+3. **TypeScript 严格模式**: 确保类型安全
+4. **错误处理**: 使用 `sonner` 库进行 Toast 提示
+5. **性能考虑**: 大数据量生成必须使用 Web Worker
+6. **响应式设计**: 支持桌面端、平板端、移动端

docs/test-data-generator/core-features.md

@@ -0,0 +1,238 @@
+# 核心功能
+
+## 功能概览
+
+| 功能模块       | 功能点        | 说明               | 优先级 |
+| -------------- | ------------- | ------------------ | ------ |
+| **字段配置**   | 添加字段      | 可视化添加数据字段 | P0     |
+|                | 删除字段      | 删除不需要的字段   | P0     |
+|                | 字段排序      | 拖拽调整字段顺序   | P1     |
+|                | 字段命名      | 自定义字段名称     | P0     |
+|                | 必填/选填设置 | 控制字段是否必填   | P0     |
+|                | 空值率配置    | 选填字段空值概率   | P1     |
+| **生成器系统** | 生成器选择    | 从生成器库中选择   | P0     |
+|                | 参数配置      | 配置生成器参数     | P0     |
+|                | 实时预览      | 配置时查看生成结果 | P1     |
+| **数据生成**   | 批量生成      | 支持 10000+ 条数据 | P0     |
+|                | 唯一性约束    | 保证字段值唯一     | P1     |
+|                | 组合策略      | 自动选择生成策略   | P1     |
+|                | 数据预览      | 生成前预览数据     | P1     |
+| **数据导出**   | JSON 导出     | 导出为 JSON 格式   | P0     |
+|                | CSV 导出      | 导出为 CSV 格式    | P0     |
+
+## 功能详情
+
+### 1. 字段配置
+
+#### 添加字段
+
+- 用户点击"添加字段"按钮
+- 弹出生成器选择器
+- 选择生成器后，自动创建新字段
+- 字段默认名称为生成器名称
+
+#### 删除字段
+
+- 每个字段右侧有删除按钮
+- 点击后弹出确认对话框
+- 确认后删除该字段
+
+#### 字段排序
+
+- 支持拖拽排序
+- 支持上移/下移按钮
+- 排序后预览数据同步更新
+
+#### 字段命名
+
+- 字段名称可自定义
+- 支持中英文命名
+- 同一规则内字段名不可重复
+
+#### 必填/选填设置
+
+- 每个字段可设置为"必填"或"选填"
+- **必填字段**: 100% 生成数据
+- **选填字段**: 可配置空值概率（0-100%）
+- 默认所有字段为必填
+
+#### 空值率配置
+
+- 选填字段可单独设置空值率
+- 提供预设值：低（20%）、中（50%）、高（80%）
+- 支持滑块精细调节（0-100%）
+- 未单独设置的选填字段使用全局默认空值率
+
+---
+
+### 2. 生成器系统
+
+#### 生成器选择
+
+- 以分类方式展示生成器
+- 支持搜索生成器
+- 点击选择后添加到字段配置
+
+#### 价格生成器（业务数据）
+
+生成真实的价格数据，支持多种策略：
+
+| 策略     | 说明                           | 适用场景     |
+| -------- | ------------------------------ | ------------ |
+| 真实分布 | 对数正态分布，模拟真实商品价格 | 通用电商场景 |
+| 均匀随机 | 所有价格等概率                 | 测试数据     |
+| 心理定价 | .99/.98/.95 结尾               | 营销场景     |
+
+**参数配置**：
+
+- 最低价/最高价：控制价格区间
+- 小数位数：0（整数）、1、2 位
+- 生成策略：选择分布类型
+
+#### 年龄生成器（个人信息）
+
+生成真实分布的年龄数据：
+
+| 策略     | 说明                         | 适用场景     |
+| -------- | ---------------------------- | ------------ |
+| 真实分布 | 正态分布，均值 35，标准差 10 | 通用用户数据 |
+| 人口比例 | 按中国人口年龄比例分布       | 市场调研数据 |
+| 均匀随机 | 所有年龄等概率               | 测试数据     |
+
+**参数配置**：
+
+- 最小年龄/最大年龄：控制年龄区间
+- 生成策略：选择分布类型
+
+#### 数量生成器（业务数据）
+
+生成真实分布的数量数据：
+
+| 策略     | 说明                        | 适用场景 |
+| -------- | --------------------------- | -------- |
+| 真实分布 | 泊松分布，大多数购买 1-3 件 | 零售订单 |
+| 批发模式 | 10-100 之间均匀分布         | 批发订单 |
+| 均匀随机 | 所有数量等概率              | 测试数据 |
+
+**参数配置**：
+
+- 最小值/最大值：控制数量区间
+- 生成策略：选择分布类型
+
+#### 评分生成器（业务数据）
+
+生成真实分布的评分数据：
+
+| 策略     | 说明               | 适用场景 |
+| -------- | ------------------ | -------- |
+| 真实分布 | 偏态分布，偏向高分 | 电商平台 |
+| 严格评价 | 偏态分布，偏向低分 | 严格评审 |
+| 均匀随机 | 所有评分等概率     | 测试数据 |
+
+**参数配置**：
+
+- 最低分/最高分：控制评分区间
+- 小数位数：0、1 位
+- 生成策略：选择分布类型
+
+#### 折扣生成器（业务数据）
+
+生成真实分布的折扣数据：
+
+| 策略     | 说明                     | 适用场景 |
+| -------- | ------------------------ | -------- |
+| 心理定价 | 常见折扣点（8折、9折等） | 电商促销 |
+| 清仓模式 | 大折扣区间（3-7折）      | 清仓处理 |
+| 均匀随机 | 所有折扣等概率           | 测试数据 |
+
+**参数配置**：
+
+- 最低折扣/最高折扣：控制折扣区间（0.1-0.9）
+- 生成策略：选择分布类型
+
+#### 库存生成器（业务数据）
+
+生成真实分布的库存数据：
+
+| 策略     | 说明                     | 适用场景 |
+| -------- | ------------------------ | -------- |
+| 真实分布 | 指数分布，大多数库存较少 | 通用商品 |
+| 热销商品 | 低库存区间（0-50）       | 热销商品 |
+| 均匀随机 | 所有库存等概率           | 测试数据 |
+
+**参数配置**：
+
+- 最小库存/最大库存：控制库存区间
+- 生成策略：选择分布类型
+
+#### 参数配置
+
+- 每个生成器有对应的参数配置界面
+- 必填参数标记星号
+- 修改参数后实时预览更新
+
+#### 实时预览
+
+- 配置参数时，右侧预览区实时更新
+- 显示 5-10 条示例数据
+- 帮助用户确认配置是否正确
+
+---
+
+### 3. 数据生成
+
+#### 批量生成
+
+- 支持配置生成数量
+- 使用 Web Worker 后台生成
+- 支持 10000+ 条数据
+- 生成过程中显示进度条
+
+#### 唯一性约束
+
+- 每个字段可单独设置唯一性约束
+- 启用后，该字段生成的值不会重复
+- 如果无法生成唯一值，使用重试机制
+
+#### 组合策略（唯一性生成）
+
+系统根据数据量自动选择最优生成策略：
+
+| 数据量    | 策略            | 说明                   |
+| --------- | --------------- | ---------------------- |
+| ≤ 1000 条 | 随机生成 + 重试 | 保证随机性，性能可接受 |
+| > 1000 条 | 索引生成        | 高性能，保证唯一性     |
+
+**实现方式**：
+
+- 生成器提供两个方法：`generate()` 和 `generateAtIndex()`
+- `generate()`: 随机生成，用于小数据量或非唯一性字段
+- `generateAtIndex()`: 索引生成，用于大数据量唯一性字段
+- 系统根据配置自动选择合适的方法
+
+**示例**：
+
+- 手机号字段：`generateAtIndex(params, index)` 使用 index 生成唯一手机号
+- 姓名字段：`generateAtIndex(params, index)` 使用 index 组合姓和名
+
+#### 数据预览
+
+- 生成前可预览数据
+- 显示前 10 条数据
+- 支持分页查看更多数据
+
+---
+
+### 4. 数据导出
+
+#### JSON 导出
+
+- 导出为标准 JSON 格式
+- 支持压缩和格式化两种模式
+- 包含字段名和数据
+
+#### CSV 导出
+
+- 导出为 CSV 格式
+- 自动处理逗号转义
+- 支持中文编码 (UTF-8 with BOM)

docs/test-data-generator/generators.md

@@ -0,0 +1,702 @@
+# 生成器库
+
+## 分类概览
+
+| 分类     | 生成器数量 | 说明                                             |
+| -------- | ---------- | ------------------------------------------------ |
+| 个人信息 | 6 个       | 中文姓名、邮箱、手机号、年龄等                   |
+| 业务数据 | 8 个       | 订单号、价格、日期、状态、数量、评分、折扣、库存 |
+| 技术数据 | 3 个       | UUID、IP地址、URL                                |
+| 基础类型 | 4 个       | 整数、浮点数、字符串等                           |
+| **总计** | **21 个**  |                                                  |
+
+---
+
+## 个人信息生成器
+
+### 1. 中文姓名 (chineseName)
+
+**说明**: 生成中文姓名，如张三、李四
+
+**参数**:
+
+| 参数名          | 类型                         | 必填 | 默认值             | 说明         |
+| --------------- | ---------------------------- | ---- | ------------------ | ------------ |
+| surnamePool     | string \| string[]           | 否   | 百家姓前100个      | 姓氏池       |
+| givenNameLength | { min: number, max: number } | 否   | { min: 1, max: 2 } | 名字长度范围 |
+
+**示例**:
+
+```json
+{
+  "name": "name",
+  "generator": "chineseName",
+  "params": {
+    "surnamePool": ["张", "王", "李", "赵"],
+    "givenNameLength": { "min": 1, "max": 2 }
+  }
+}
+```
+
+**生成结果**: 张伟, 李娜, 王强, 赵敏
+
+---
+
+### 2. 邮箱地址 (email)
+
+**说明**: 生成邮箱地址
+
+**参数**:
+
+| 参数名    | 类型                 | 必填 | 默认值                                                       | 说明       |
+| --------- | -------------------- | ---- | ------------------------------------------------------------ | ---------- |
+| domains   | string[]             | 否   | ['qq.com', '163.com', '126.com', 'gmail.com', 'outlook.com'] | 域名列表   |
+| nameStyle | 'pinyin' \| 'random' | 否   | 'pinyin'                                                     | 用户名风格 |
+
+**示例**:
+
+```json
+{
+  "name": "email",
+  "generator": "email",
+  "params": {
+    "domains": ["qq.com", "163.com"],
+    "nameStyle": "pinyin"
+  }
+}
+```
+
+**生成结果**: zhangwei@qq.com, lina@163.com
+
+---
+
+### 3. 中国手机号 (chinesePhone)
+
+**说明**: 生成 11 位中国手机号
+
+**参数**:
+
+| 参数名 | 类型     | 必填 | 默认值         | 说明       |
+| ------ | -------- | ---- | -------------- | ---------- |
+| prefix | string[] | 否   | 常见手机号前缀 | 手机号前缀 |
+
+**示例**:
+
+```json
+{
+  "name": "phone",
+  "generator": "chinesePhone",
+  "params": {
+    "prefix": ["138", "139", "150", "151"]
+  }
+}
+```
+
+**生成结果**: 13812345678, 15087654321
+
+---
+
+### 4. 身份证号 (idCard)
+
+**说明**: 生成 18 位中国身份证号
+
+**参数**:
+
+| 参数名 | 类型   | 必填 | 默认值 | 说明   |
+| ------ | ------ | ---- | ------ | ------ |
+| region | string | 否   | 随机   | 地区码 |
+
+**示例**:
+
+```json
+{
+  "name": "idCard",
+  "generator": "idCard",
+  "params": {
+    "region": "110101"
+  }
+}
+```
+
+**生成结果**: 110101199001011234
+
+---
+
+### 5. 中文地址 (chineseAddress)
+
+**说明**: 生成中国地址
+
+**参数**:
+
+| 参数名 | 类型                           | 必填 | 默认值 | 说明     |
+| ------ | ------------------------------ | ---- | ------ | -------- |
+| level  | 'full' \| 'province' \| 'city' | 否   | 'full' | 详细程度 |
+
+**示例**:
+
+```json
+{
+  "name": "address",
+  "generator": "chineseAddress",
+  "params": {
+    "level": "full"
+  }
+}
+```
+
+**生成结果**: 北京市朝阳区建国路88号
+
+---
+
+### 6. 年龄 (age)
+
+**说明**: 生成真实分布的年龄数据
+
+**参数**:
+
+| 参数名   | 类型                                      | 必填 | 默认值      | 说明     |
+| -------- | ----------------------------------------- | ---- | ----------- | -------- |
+| min      | number                                    | 否   | 1           | 最小年龄 |
+| max      | number                                    | 否   | 100         | 最大年龄 |
+| strategy | 'realistic' \| 'demographic' \| 'uniform' | 否   | 'realistic' | 生成策略 |
+
+**策略说明**:
+
+| 策略        | 说明                         | 适用场景     |
+| ----------- | ---------------------------- | ------------ |
+| realistic   | 正态分布，均值 35，标准差 10 | 通用用户数据 |
+| demographic | 按中国人口年龄比例分布       | 市场调研数据 |
+| uniform     | 均匀随机                     | 测试数据     |
+
+**示例**:
+
+```json
+{
+  "name": "age",
+  "generator": "age",
+  "params": {
+    "min": 18,
+    "max": 65,
+    "strategy": "realistic"
+  }
+}
+```
+
+**生成结果**: 28, 42, 35, 51, 23
+
+---
+
+## 业务数据生成器
+
+### 1. 订单号 (orderId)
+
+**说明**: 生成订单号
+
+**参数**:
+
+| 参数名       | 类型    | 必填 | 默认值 | 说明         |
+| ------------ | ------- | ---- | ------ | ------------ |
+| prefix       | string  | 否   | 'ORD'  | 前缀         |
+| dateIncluded | boolean | 否   | true   | 是否包含日期 |
+
+**示例**:
+
+```json
+{
+  "name": "orderId",
+  "generator": "orderId",
+  "params": {
+    "prefix": "ORD",
+    "dateIncluded": true
+  }
+}
+```
+
+**生成结果**: ORD20240115001, ORD20240115002
+
+---
+
+### 2. 价格 (price)
+
+**说明**: 生成真实的价格数据，支持多种分布策略
+
+**参数**:
+
+| 参数名   | 类型                                        | 必填 | 默认值      | 说明     |
+| -------- | ------------------------------------------- | ---- | ----------- | -------- |
+| min      | number                                      | 是   | 1           | 最低价   |
+| max      | number                                      | 是   | 9999        | 最高价   |
+| decimals | 0 \| 1 \| 2                                 | 否   | 2           | 小数位数 |
+| strategy | 'realistic' \| 'uniform' \| 'psychological' | 否   | 'realistic' | 生成策略 |
+
+**生成策略说明**:
+
+| 策略          | 说明                           | 适用场景     |
+| ------------- | ------------------------------ | ------------ |
+| realistic     | 对数正态分布，模拟真实商品价格 | 通用电商场景 |
+| uniform       | 均匀随机，所有价格等概率       | 测试数据     |
+| psychological | 心理定价，.99/.98/.95 结尾     | 营销场景     |
+
+**示例**:
+
+```json
+{
+  "name": "price",
+  "generator": "price",
+  "params": {
+    "min": 10,
+    "max": 5000,
+    "decimals": 2,
+    "strategy": "realistic"
+  }
+}
+```
+
+**生成结果**:
+
+- 真实分布: 299.00, 1599.50, 49.99, 1299.00
+- 心理定价: 299.99, 1599.98, 49.95, 1299.99
+- 均匀随机: 1234.56, 5678.90, 890.12
+
+---
+
+### 3. 日期时间 (date)
+
+**说明**: 生成日期时间
+
+**参数**:
+
+| 参数名 | 类型   | 必填 | 默认值                | 说明     |
+| ------ | ------ | ---- | --------------------- | -------- |
+| format | string | 否   | 'YYYY-MM-DD HH:mm:ss' | 日期格式 |
+| min    | string | 否   | '2020-01-01'          | 最早日期 |
+| max    | string | 否   | 当前日期              | 最晚日期 |
+
+**示例**:
+
+```json
+{
+  "name": "createdAt",
+  "generator": "date",
+  "params": {
+    "format": "YYYY-MM-DD HH:mm:ss",
+    "min": "2024-01-01"
+  }
+}
+```
+
+**生成结果**: 2024-01-15 14:30:22
+
+---
+
+### 4. 状态 (status)
+
+**说明**: 从选项中随机选择
+
+**参数**:
+
+| 参数名  | 类型     | 必填 | 默认值   | 说明         |
+| ------- | -------- | ---- | -------- | ------------ |
+| options | string[] | 是   | -        | 状态选项列表 |
+| weights | number[] | 否   | 均匀分布 | 各选项权重   |
+
+**示例**:
+
+```json
+{
+  "name": "status",
+  "generator": "status",
+  "params": {
+    "options": ["pending", "paid", "shipped", "completed"],
+    "weights": [30, 40, 20, 10]
+  }
+}
+```
+
+**生成结果**: pending, paid, shipped, completed
+
+---
+
+### 5. 数量 (quantity)
+
+**说明**: 生成真实分布的数量数据
+
+**参数**:
+
+| 参数名   | 类型                               | 必填 | 默认值      | 说明     |
+| -------- | ---------------------------------- | ---- | ----------- | -------- |
+| min      | number                             | 否   | 1           | 最小值   |
+| max      | number                             | 否   | 100         | 最大值   |
+| strategy | 'realistic' \| 'bulk' \| 'uniform' | 否   | 'realistic' | 生成策略 |
+
+**策略说明**:
+
+| 策略      | 说明                        | 适用场景 |
+| --------- | --------------------------- | -------- |
+| realistic | 泊松分布，大多数购买 1-3 件 | 零售订单 |
+| bulk      | 10-100 之间均匀分布         | 批发订单 |
+| uniform   | 均匀随机                    | 测试数据 |
+
+**示例**:
+
+```json
+{
+  "name": "quantity",
+  "generator": "quantity",
+  "params": {
+    "min": 1,
+    "max": 50,
+    "strategy": "realistic"
+  }
+}
+```
+
+**生成结果**: 2, 1, 5, 3, 1
+
+---
+
+### 6. 评分 (rating)
+
+**说明**: 生成真实分布的评分数据
+
+**参数**:
+
+| 参数名   | 类型                                 | 必填 | 默认值      | 说明     |
+| -------- | ------------------------------------ | ---- | ----------- | -------- |
+| min      | number                               | 否   | 1           | 最低分   |
+| max      | number                               | 否   | 5           | 最高分   |
+| decimals | number                               | 否   | 1           | 小数位数 |
+| strategy | 'realistic' \| 'strict' \| 'uniform' | 否   | 'realistic' | 生成策略 |
+
+**策略说明**:
+
+| 策略      | 说明               | 适用场景 |
+| --------- | ------------------ | -------- |
+| realistic | 偏态分布，偏向高分 | 电商平台 |
+| strict    | 偏态分布，偏向低分 | 严格评审 |
+| uniform   | 均匀随机           | 测试数据 |
+
+**示例**:
+
+```json
+{
+  "name": "rating",
+  "generator": "rating",
+  "params": {
+    "min": 1,
+    "max": 5,
+    "decimals": 1,
+    "strategy": "realistic"
+  }
+}
+```
+
+**生成结果**: 4.5, 4.8, 3.9, 5.0, 4.2
+
+---
+
+### 7. 折扣 (discount)
+
+**说明**: 生成真实分布的折扣数据
+
+**参数**:
+
+| 参数名   | 类型                                        | 必填 | 默认值          | 说明     |
+| -------- | ------------------------------------------- | ---- | --------------- | -------- |
+| min      | number                                      | 否   | 0.1             | 最低折扣 |
+| max      | number                                      | 否   | 0.9             | 最高折扣 |
+| strategy | 'psychological' \| 'clearance' \| 'uniform' | 否   | 'psychological' | 生成策略 |
+
+**策略说明**:
+
+| 策略          | 说明                     | 适用场景 |
+| ------------- | ------------------------ | -------- |
+| psychological | 常见折扣点（8折、9折等） | 电商促销 |
+| clearance     | 大折扣区间（3-7折）      | 清仓处理 |
+| uniform       | 均匀随机                 | 测试数据 |
+
+**示例**:
+
+```json
+{
+  "name": "discount",
+  "generator": "discount",
+  "params": {
+    "min": 0.1,
+    "max": 0.9,
+    "strategy": "psychological"
+  }
+}
+```
+
+**生成结果**: 0.80, 0.90, 0.85, 0.95, 0.70
+
+---
+
+### 8. 库存 (stock)
+
+**说明**: 生成真实分布的库存数据
+
+**参数**:
+
+| 参数名   | 类型                              | 必填 | 默认值      | 说明     |
+| -------- | --------------------------------- | ---- | ----------- | -------- |
+| min      | number                            | 否   | 0           | 最小库存 |
+| max      | number                            | 否   | 1000        | 最大库存 |
+| strategy | 'realistic' \| 'hot' \| 'uniform' | 否   | 'realistic' | 生成策略 |
+
+**策略说明**:
+
+| 策略      | 说明                     | 适用场景 |
+| --------- | ------------------------ | -------- |
+| realistic | 指数分布，大多数库存较少 | 通用商品 |
+| hot       | 低库存区间（0-50）       | 热销商品 |
+| uniform   | 均匀随机                 | 测试数据 |
+
+**示例**:
+
+```json
+{
+  "name": "stock",
+  "generator": "stock",
+  "params": {
+    "min": 0,
+    "max": 500,
+    "strategy": "realistic"
+  }
+}
+```
+
+**生成结果**: 23, 8, 156, 45, 12
+
+---
+
+## 技术数据生成器
+
+### 1. UUID (uuid)
+
+**说明**: 生成 UUID
+
+**参数**:
+
+| 参数名  | 类型         | 必填 | 默认值 | 说明      |
+| ------- | ------------ | ---- | ------ | --------- |
+| version | 'v4' \| 'v1' | 否   | 'v4'   | UUID 版本 |
+
+**示例**:
+
+```json
+{
+  "name": "id",
+  "generator": "uuid",
+  "params": {
+    "version": "v4"
+  }
+}
+```
+
+**生成结果**: 550e8400-e29b-41d4-a716-446655440000
+
+---
+
+### 2. IPv4 地址 (ipv4)
+
+**说明**: 生成 IPv4 地址
+
+**参数**:
+
+| 参数名  | 类型    | 必填 | 默认值 | 说明         |
+| ------- | ------- | ---- | ------ | ------------ |
+| private | boolean | 否   | false  | 是否私有地址 |
+
+**示例**:
+
+```json
+{
+  "name": "ip",
+  "generator": "ipv4",
+  "params": {
+    "private": true
+  }
+}
+```
+
+**生成结果**: 192.168.1.1, 10.0.0.1
+
+---
+
+### 3. URL (url)
+
+**说明**: 生成 URL
+
+**参数**:
+
+| 参数名   | 类型              | 必填 | 默认值        | 说明 |
+| -------- | ----------------- | ---- | ------------- | ---- |
+| protocol | 'http' \| 'https' | 否   | 'https'       | 协议 |
+| domain   | string            | 否   | 'example.com' | 域名 |
+
+**示例**:
+
+```json
+{
+  "name": "website",
+  "generator": "url",
+  "params": {
+    "protocol": "https",
+    "domain": "shop.com"
+  }
+}
+```
+
+**生成结果**: https://shop.com/product/123
+
+---
+
+## 基础类型生成器
+
+### 1. 随机整数 (randomInt)
+
+**说明**: 生成指定范围的随机整数
+
+**参数**:
+
+| 参数名 | 类型   | 必填 | 默认值 | 说明   |
+| ------ | ------ | ---- | ------ | ------ |
+| min    | number | 是   | -      | 最小值 |
+| max    | number | 是   | -      | 最大值 |
+
+**示例**:
+
+```json
+{
+  "name": "age",
+  "generator": "randomInt",
+  "params": {
+    "min": 18,
+    "max": 60
+  }
+}
+```
+
+**生成结果**: 25, 42, 18, 60
+
+---
+
+### 2. 随机浮点数 (randomFloat)
+
+**说明**: 生成指定范围的随机浮点数
+
+**参数**:
+
+| 参数名   | 类型   | 必填 | 默认值 | 说明     |
+| -------- | ------ | ---- | ------ | -------- |
+| min      | number | 是   | -      | 最小值   |
+| max      | number | 是   | -      | 最大值   |
+| decimals | number | 否   | 2      | 小数位数 |
+
+**示例**:
+
+```json
+{
+  "name": "score",
+  "generator": "randomFloat",
+  "params": {
+    "min": 0,
+    "max": 100,
+    "decimals": 1
+  }
+}
+```
+
+**生成结果**: 85.3, 42.7, 99.9
+
+---
+
+### 3. 随机字符串 (randomString)
+
+**说明**: 生成指定长度的随机字符串
+
+**参数**:
+
+| 参数名  | 类型   | 必填 | 默认值         | 说明       |
+| ------- | ------ | ---- | -------------- | ---------- |
+| length  | number | 是   | -              | 字符串长度 |
+| charset | string | 否   | 'alphanumeric' | 字符集     |
+
+**示例**:
+
+```json
+{
+  "name": "code",
+  "generator": "randomString",
+  "params": {
+    "length": 8,
+    "charset": "alphanumeric"
+  }
+}
+```
+
+**生成结果**: aB3kL9mN, xY7zW2pQ
+
+---
+
+### 4. 从列表选择 (fromList)
+
+**说明**: 从选项列表中随机选择
+
+**参数**:
+
+| 参数名  | 类型     | 必填 | 默认值   | 说明     |
+| ------- | -------- | ---- | -------- | -------- |
+| options | any[]    | 是   | -        | 选项列表 |
+| weights | number[] | 否   | 均匀分布 | 权重     |
+
+**示例**:
+
+```json
+{
+  "name": "category",
+  "generator": "fromList",
+  "params": {
+    "options": ["电子产品", "服装", "食品", "图书"],
+    "weights": [40, 30, 20, 10]
+  }
+}
+```
+
+**生成结果**: 电子产品, 服装, 食品
+
+---
+
+## 生成器选择界面
+
+### 界面设计
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  选择生成器                                                       │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  搜索: [搜索生成器...                                          ] │
+│                                                                     │
+│  分类筛选                                                        │
+│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐      │
+│  │ 全部    │ │ 个人信息 │ │ 业务数据 │ │ 技术数据 │ │ 基础类型 │      │
+│  └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘      │
+│                                                                     │
+│  生成器列表                                                       │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │  个人信息                                                     │ │
+│  │  ┌─────────────────────────────────────────────────────────┐ │ │
+│  │  │ 中文姓名        生成中文姓名，如张三                     │ │ │
+│  │  │ 邮箱地址        生成邮箱地址                            │ │ │
+│  │  │ 中国手机号      生成11位手机号                          │ │ │
+│  │  │ 身份证号        生成18位身份证号                        │ │ │
+│  │  │ 中文地址        生成中国地址                            │ │ │
+│  │  └─────────────────────────────────────────────────────────┘ │ │
+│  │                                                               │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```

docs/test-data-generator/rule-management.md

@@ -0,0 +1,481 @@
+# 规则管理
+
+## 功能概览
+
+| 功能     | 说明                 | 优先级 |
+| -------- | -------------------- | ------ |
+| 保存规则 | 将当前配置保存为模板 | P0     |
+| 规则列表 | 查看所有已保存的规则 | P0     |
+| 规则搜索 | 按关键词搜索规则     | P1     |
+| 规则编辑 | 修改已保存的规则     | P0     |
+| 规则删除 | 删除不需要的规则     | P0     |
+| 规则加载 | 一键加载规则配置     | P0     |
+| 规则复制 | 复制规则配置         | P1     |
+| 规则导出 | 导出为 JSON 文件     | P1     |
+| 规则导入 | 从 JSON 文件导入     | P1     |
+
+## 规则数量限制
+
+- **最大规则数量**: 20 条
+- **超出限制**: 当规则数量达到 20 条时，保存按钮置灰，提示"已达到最大规则数量"
+- **解决方式**: 用户需要删除已有规则后才能保存新规则
+
+---
+
+## 数据结构
+
+### 规则模板
+
+```typescript
+interface DataRule {
+  id: string; // 唯一标识
+  name: string; // 规则名称
+  description?: string; // 规则描述
+  fields: FieldConfig[]; // 字段配置
+  options: {
+    total: number; // 生成数量
+    format: 'json' | 'csv';
+    defaultEmptyRate: number; // 默认空值率（0-100）
+  };
+  metadata: {
+    createdAt: number; // 创建时间
+    updatedAt: number; // 更新时间
+    lastUsedAt?: number; // 最后使用时间
+    useCount: number; // 使用次数
+  };
+}
+```
+
+### 字段配置
+
+```typescript
+interface FieldConfig {
+  id: string; // 字段唯一标识
+  name: string; // 字段名
+  generator: string; // 生成器名称
+  params: Record<string, any>; // 生成器参数
+  unique: boolean; // 唯一性约束
+  required: boolean; // 是否必填
+  emptyRate?: number; // 选填字段的空值概率（0-100）
+}
+```
+
+---
+
+## 功能详情
+
+### 1. 保存规则
+
+**触发方式**: 用户点击"保存规则"按钮
+
+**界面设计**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  保存规则                                                            │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  规则信息                                                            │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │  规则名称:                                                     │ │
+│  │  ┌─────────────────────────────────────────────────────────┐ │ │
+│  │  │ [电商用户数据 - 测试用                                  ]│ │ │
+│  │  └─────────────────────────────────────────────────────────┘ │ │
+│  │                                                               │ │
+│  │  规则描述 (可选):                                              │ │
+│  │  ┌─────────────────────────────────────────────────────────┐ │ │
+│  │  │ [用于测试用户注册功能，包含姓名、邮箱、手机号            ]│ │ │
+│  │  └─────────────────────────────────────────────────────────┘ │ │
+│  │                                                               │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  规则预览                                                            │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ 字段数量: 4 个                                                 │ │
+│  │ • name (中文姓名)                                              │ │
+│  │ • email (邮箱地址)                                             │ │
+│  │ • phone (手机号)                                               │ │
+│  │ • age (年龄)                                                   │ │
+│  │                                                               │ │
+│  │ 生成数量: 100 条                                               │ │
+│  │ 数据格式: JSON                                                 │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  [保存]  [取消]                                                      │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**保存逻辑**:
+
+1. 验证规则名称不为空
+2. 检查规则数量是否达到上限（20 条）
+3. 如果达到上限，显示提示"已达到最大规则数量"
+4. 生成唯一 ID
+5. 设置创建时间和更新时间
+6. 初始化使用次数为 0
+7. 保存到 localStorage
+
+---
+
+### 2. 规则列表
+
+**界面设计**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  规则管理                                                            │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  搜索: [搜索规则名称...                                            ] │
+│                                                                     │
+│  规则列表 (已保存 15/20 条)                                          │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │                                                               │ │
+│  │  ┌─────────────────────────────────────────────────────────┐ │ │
+│  │  │ 电商用户数据 - 测试用                                     │ │ │
+│  │  │ ─────────────────────────────────────────────────────── │ │ │
+│  │  │ 用于测试用户注册功能，包含姓名、邮箱、手机号              │ │ │
+│  │  │ 4 个字段 | 100 条 | JSON                                  │ │ │
+│  │  │ 2024-01-15 14:30 创建 | 2024-01-20 10:15 最后使用        │ │ │
+│  │  │                                                         │ │ │
+│  │  │ [加载]  [复制]  [导出]  [编辑]  [删除]                     │ │ │
+│  │  └─────────────────────────────────────────────────────────┘ │ │
+│  │                                                               │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  [导入规则]  [导出全部]  [清空全部]                                  │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**列表项信息**:
+
+- 规则名称
+- 规则描述
+- 字段数量、生成数量、数据格式
+- 创建时间、最后使用时间
+- 操作按钮
+
+---
+
+### 3. 规则搜索
+
+**搜索逻辑**:
+
+- 支持按规则名称搜索
+- 支持按规则描述搜索
+- 搜索为模糊匹配，不区分大小写
+
+**实现方式**:
+
+```typescript
+search(keyword: string): DataRule[] {
+  const rules = this.getAll();
+  const lowerKeyword = keyword.toLowerCase();
+
+  return rules.filter(r =>
+    r.name.toLowerCase().includes(lowerKeyword) ||
+    r.description?.toLowerCase().includes(lowerKeyword)
+  );
+}
+```
+
+---
+
+### 4. 规则编辑
+
+**界面设计**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  编辑规则 - 电商用户数据                                             │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  基本信息                                                            │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ 规则名称: [电商用户数据 - 测试用                              ]│ │
+│  │ 规则描述: [用于测试用户注册功能，包含姓名、邮箱、手机号        ]│ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  字段配置 (可直接编辑)                                                │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │                                                               │ │
+│  │  1. name        [中文姓名 ▼]  [配置] [删除] [上移][下移]      │ │
+│  │  2. email       [邮箱地址 ▼]  [配置] [删除] [上移][下移]      │ │
+│  │  3. phone       [手机号   ▼]  [配置] [删除] [上移][下移]      │ │
+│  │  4. age         [年龄     ▼]  [配置] [删除] [上移][下移]      │ │
+│  │                                                               │ │
+│  │  [+ 添加字段]                                                 │ │
+│  │                                                               │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  生成选项                                                            │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ 数量: [100]  格式: [JSON ▼]                                   │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  [保存修改]  [取消]                                                  │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**编辑逻辑**:
+
+1. 加载原规则配置到编辑器
+2. 用户修改配置
+3. 点击保存时更新规则
+4. 更新 metadata.updatedAt
+5. 保存到 localStorage
+
+---
+
+### 5. 规则删除
+
+**删除流程**:
+
+1. 点击删除按钮
+2. 弹出确认对话框
+3. 确认后删除规则
+4. 刷新规则列表
+
+**确认对话框**:
+
+```
+┌─────────────────────────────────────────┐
+│  确认删除                            │
+├─────────────────────────────────────────┤
+│                                         │
+│  确定要删除规则 "电商用户数据" 吗？      │
+│                                         │
+│  此操作不可撤销。                        │
+│                                         │
+│  [取消]  [删除]                     │
+│                                         │
+└─────────────────────────────────────────┘
+```
+
+---
+
+### 6. 规则加载
+
+**加载流程**:
+
+1. 点击"加载"按钮
+2. 将规则配置应用到当前编辑器
+3. 更新预览数据
+4. 记录使用时间和次数
+
+**实现方式**:
+
+```typescript
+loadRule(ruleId: string): void {
+  const rule = this.storage.getById(ruleId);
+
+  // 应用规则配置
+  this.setFields(rule.fields);
+  this.setOptions(rule.options);
+
+  // 记录使用
+  this.storage.recordUse(ruleId);
+
+  // 更新预览
+  this.updatePreview();
+}
+```
+
+---
+
+### 7. 规则复制
+
+**复制逻辑**:
+
+1. 点击"复制"按钮
+2. 创建规则的副本
+3. 名称添加"(副本)"后缀
+4. 生成新的 ID
+5. 保存为新规则
+
+---
+
+### 8. 规则导出
+
+**导出界面**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  导出规则                                                            │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  选择要导出的规则:                                                    │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ ☑ 电商用户数据 - 测试用 (4个字段, 100条)                       │ │
+│  │ ☑ 电商订单数据 - 测试用 (6个字段, 500条)                       │ │
+│  │ ☐ 用户登录数据 - 测试用 (3个字段, 50条)                       │ │
+│  │                                                               │ │
+│  │ [全选]  [全不选]                                               │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  导出格式:                                                            │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ ○ 导出为单个 JSON 文件 (所有规则合并)                          │ │
+│  │ ● 导出为多个 JSON 文件 (每个规则一个文件)                      │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  [导出]  [取消]                                                      │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**导出格式**:
+
+```json
+{
+  "version": "1.0",
+  "exportedAt": "2024-01-20T10:15:45.000Z",
+  "rules": [
+    {
+      "id": "rule_123456",
+      "name": "电商用户数据 - 测试用",
+      "description": "用于测试用户注册功能",
+      "fields": [...],
+      "options": {...},
+      "metadata": {...}
+    }
+  ]
+}
+```
+
+---
+
+### 9. 规则导入
+
+**导入界面**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  导入规则                                                            │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  选择导入方式:                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │                                                               │ │
+│  │  ○ 从文件导入                                                 │ │
+│  │    ┌─────────────────────────────────────────────────────┐   │ │
+│  │    │ 拖拽文件到这里，或 [点击选择文件]                      │   │ │
+│  │    │ 支持格式: .json                                      │   │ │
+│  │    └─────────────────────────────────────────────────────┘   │ │
+│  │                                                               │ │
+│  │  ○ 从剪贴板粘贴                                               │ │
+│  │    ┌─────────────────────────────────────────────────────┐   │ │
+│  │    │ 粘贴 JSON 规则内容...                                │   │ │
+│  │    └─────────────────────────────────────────────────────┘   │ │
+│  │                                                               │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  预览导入内容:                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ 格式验证通过                                                   │ │
+│  │ 规则数量: 2 个                                                │ │
+│  │ • 电商用户数据 (4个字段)                                       │ │
+│  │ • 电商订单数据 (6个字段)                                       │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  [导入]  [取消]                                                      │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**导入逻辑**:
+
+1. 解析 JSON 文件
+2. 验证格式是否正确
+3. 预览导入内容
+4. 确认后逐条导入
+5. 生成新 ID 避免冲突
+6. 处理导入结果（成功/失败数量）
+
+---
+
+## 存储机制
+
+### 本地存储
+
+使用 localStorage 存储规则数据:
+
+```typescript
+class RuleStorage {
+  private readonly STORAGE_KEY = 'testDataGenerator_rules';
+
+  // 获取所有规则
+  getAll(): DataRule[] {
+    const data = localStorage.getItem(this.STORAGE_KEY);
+    return data ? JSON.parse(data) : [];
+  }
+
+  // 保存规则
+  save(rule: DataRule): { success: boolean; message?: string } {
+    const rules = this.getAll();
+
+    // 规则数量限制：最多 20 条
+    const MAX_RULES = 20;
+    if (rules.length >= MAX_RULES) {
+      return {
+        success: false,
+        message: `已达到最大规则数量（${MAX_RULES}条），请删除一些规则后再保存`,
+      };
+    }
+
+    rules.push(rule);
+    localStorage.setItem(this.STORAGE_KEY, JSON.stringify(rules));
+    return { success: true };
+  }
+
+  // 更新规则
+  update(id: string, updates: Partial<DataRule>): void {
+    const rules = this.getAll();
+    const index = rules.findIndex((r) => r.id === id);
+    if (index !== -1) {
+      rules[index] = { ...rules[index], ...updates };
+      localStorage.setItem(this.STORAGE_KEY, JSON.stringify(rules));
+    }
+  }
+
+  // 删除规则
+  delete(id: string): void {
+    const rules = this.getAll();
+    const filtered = rules.filter((r) => r.id !== id);
+    localStorage.setItem(this.STORAGE_KEY, JSON.stringify(filtered));
+  }
+
+  // 记录使用
+  recordUse(id: string): void {
+    const rules = this.getAll();
+    const rule = rules.find((r) => r.id === id);
+    if (rule) {
+      rule.metadata.lastUsedAt = Date.now();
+      rule.metadata.useCount++;
+      localStorage.setItem(this.STORAGE_KEY, JSON.stringify(rules));
+    }
+  }
+}
+```
+
+### 存储限制
+
+- **规则数量限制**: 最多 20 条
+- localStorage 容量: 5-10MB（浏览器限制）
+- 单个规则约 1-5KB
+- 预计可存储 1000-5000 个规则（但受数量限制，最多 20 条）
+
+---
+
+## 功能亮点
+
+| 亮点     | 说明                           |
+| -------- | ------------------------------ |
+| 本地存储 | 数据保存在浏览器本地，无需后端 |
+| 快速复用 | 一键加载已保存的规则           |
+| 导入导出 | 支持 JSON 文件导入导出         |
+| 使用统计 | 记录使用次数和时间             |
+| 搜索筛选 | 支持关键词搜索                 |

docs/test-data-generator/ui-design.md

@@ -0,0 +1,489 @@
+# 界面设计
+
+## 设计原则
+
+1. **简洁直观** - 一目了然的布局
+2. **操作便捷** - 减少点击次数
+3. **实时反馈** - 配置即预览
+4. **响应式** - 支持多种屏幕尺寸
+
+---
+
+## 页面结构
+
+### 主页面布局
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  🧪 测试数据生成器                                          [帮助] │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  ┌─────────────────────────────────────┐ ┌───────────────────────┐ │
+│  │  字段配置                             │ │  数据预览              │ │
+│  │                                     │ │                       │ │
+│  │  [+ 添加字段]                        │ │  [实时预览数据]       │ │
+│  │                                     │ │                       │ │
+│  │  字段列表...                         │ │                       │ │
+│  │                                     │ │                       │ │
+│  └─────────────────────────────────────┘ └───────────────────────┘ │
+│                                                                     │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │  生成选项                                                       │ │
+│  │  数量、格式、约束...                                          │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │  操作栏                                                     │ │
+│  │  [生成]  [保存规则]  [规则管理]                       │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 组件设计
+
+### 1. 字段列表组件
+
+**功能**: 展示和管理所有字段
+
+**界面**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  字段配置                                                         │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  [+ 添加字段]                                                        │
+│                                                                     │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ 1. name        [中文姓名 ▼]  [配置] [删除] [上移][下移]             │ │
+│  │ 2. email       [邮箱地址 ▼]  [配置] [删除] [上移][下移]             │ │
+│  │ 3. phone       [手机号   ▼]  [配置] [删除] [上移][下移]             │ │
+│  │ 4. age         [年龄     ▼]  [配置] [删除] [上移][下移]             │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  [+ 添加字段]                                                        │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**交互**:
+
+- 点击字段名可编辑
+- 点击生成器下拉框可切换生成器
+- 点击 配置 展开参数配置
+- 点击 删除 删除字段
+- 点击 上移下移 调整顺序
+
+---
+
+### 2. 字段配置组件
+
+**功能**: 配置单个字段的详细参数
+
+**界面**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  字段配置                                                            │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  基础配置                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ 字段名称:  [name                                         ]   │ │
+│  │ 字段描述:  [用户姓名                                     ]   │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  生成器选择                                                      │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ 分类: [个人信息 ▼]                                         │   │
+│  │ 生成器: [中文姓名 ▼]                                        │   │
+│  │ 说明: 生成中文姓名，如张三、李四                           │   │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  参数配置                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ 姓氏池: [百家姓前100 ▼]                                      │ │
+│  │ 名字长度: [1] ~ [2]                                          │ │
+│  │ ☑ 唯一性约束                                                 │ │
+│  │ ☑ 必填                                                       │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  空值率设置 (仅选填字段显示)                                       │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ 空值概率: [====|----] 50%                                     │ │
+│  │ 预设: [低 20%] [中 50%] [高 80%]                              │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  预览示例                                                         │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ 张伟, 李娜, 王强, 赵敏, 刘洋                                  │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  [保存]  [取消]                                                │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**交互说明**:
+
+- **必填复选框**: 勾选后该字段必填，100% 生成数据
+- **空值率设置**: 仅当选填时显示，控制该字段生成空值的概率
+- **预设按钮**: 快速设置常用空值率（低/中/高）
+- **空值率滑块**: 精细调节空值概率（0-100%）
+
+---
+
+### 3. 数据预览组件
+
+**功能**: 实时预览生成的数据
+
+**界面**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  数据预览                                                         │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  预览: 前 10 条                                                   │
+│                                                                     │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ {                                                             │ │
+│  │   "name": "张伟",                                             │ │
+│  │   "email": "zhangwei@qq.com",                                 │ │
+│  │   "phone": "13812345678",                                     │ │
+│  │   "age": 28                                                   │ │
+│  │ },                                                            │ │
+│  │ {                                                             │ │
+│  │   "name": "李娜",                                             │ │
+│  │   "email": "lina@163.com",                                    │ │
+│  │   "phone": "13987654321",                                     │ │
+│  │   "age": 35                                                   │ │
+│  │ },                                                            │ │
+│  │ ...                                                           │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  格式切换:                                                        │
+│  [JSON]  [CSV]                                                      │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**功能**:
+
+- 实时更新预览
+- 支持格式切换
+- 分页显示更多数据
+- 一键复制
+
+---
+
+### 4. 生成选项组件
+
+**功能**: 配置生成参数
+
+**界面**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  生成选项                                                         │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  ┌─────────────────┐ ┌─────────────────┐ ┌───────────────────────┐ │
+│  │ 生成数量      │ │ 数据格式      │ │ 约束条件           │ │
+│  │                 │ │                 │ │                       │ │
+│  │ [100         ] │ │ ○ JSON          │ │ ☑ name 唯一          │ │
+│  │ [10 ▼]          │ │ ○ CSV           │ │ ☑ email 唯一         │ │
+│  │ [100 ▼]         │ │                 │ │ ☑ phone 唯一         │ │
+│  │ [自定义    ]  │ │                 │ │ ☐ age 唯一           │ │
+│  │                 │ │                 │ │                       │ │
+│  └─────────────────┘ └─────────────────┘ └───────────────────────┘ │
+│                                                                     │
+│  默认空值率 (选填字段)                                             │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ 空值概率: [====|----] 50%                                     │ │
+│  │ 预设: [低 20%] [中 50%] [高 80%]                              │ │
+│  │ 说明: 未单独设置空值率的选填字段将使用此默认值                │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+### 5. 操作栏组件
+
+**功能**: 顶部操作按钮
+
+**界面**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  操作栏                                                           │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  [生成数据]  [保存规则]  [规则管理]  [导入规则]  [导出]│
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+### 6. 生成结果组件
+
+**功能**: 展示生成结果，包含成功、警告、错误三种状态
+
+**成功状态界面**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  生成结果                                                         │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  生成完成                                                          │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ [成功图标] 成功生成 100 条数据，耗时 1234ms                  │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  数据统计:                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ • 总条数: 100                                                 │ │
+│  │ • 成功条数: 100                                               │ │
+│  │ • 失败条数: 0                                                 │ │
+│  │ • 文件大小: 12.5 KB                                           │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  数据预览:                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ [JSON 格式预览...]                                            │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  导出选项:                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ [复制全部]  [下载 JSON]  [下载 CSV]                           │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  [关闭]                                                           │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**警告状态界面（部分字段失败）**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  生成结果                                                         │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  部分字段生成失败                                                  │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ [警告图标] 有 2 个字段生成失败                               │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  失败详情:                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ [警告图标] "phone" - 重试 100 次后仍存在重复                  │ │
+│  │ [警告图标] "email" - 重试 100 次后仍存在重复                  │ │
+│  │                                                               │ │
+│  │ 提示: 这些字段的值已设置为空，您可以尝试减少生成数量          │ │
+│  │       或调整字段配置                                          │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  数据统计:                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ • 总条数: 100                                                 │ │
+│  │ • 成功条数: 98                                                │ │
+│  │ • 失败条数: 2                                                 │ │
+│  │ • 文件大小: 12.3 KB                                           │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  数据预览:                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ [JSON 格式预览...]                                            │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  导出选项:                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ [复制全部]  [下载 JSON]  [下载 CSV]                           │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  [关闭]                                                           │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**错误状态界面（生成失败）**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  生成失败                                                         │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ [错误图标] 生成过程中发生错误                                │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  错误详情:                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │                                                               │ │
+│  │  错误类型: 生成器不存在                                      │ │
+│  │  错误信息: 字段 "phone" 的生成器 "chinesePhone1" 不存在      │ │
+│  │  错误位置: 字段配置第 2 行                                   │ │
+│  │                                                               │ │
+│  │  建议操作:                                                   │ │
+│  │  1. 检查字段配置中的生成器名称是否正确                       │ │
+│  │  2. 确认该生成器已正确注册                                   │ │
+│  │                                                               │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  [重新配置]  [关闭]                                                │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+### 6.1 Toast 提示组件
+
+**功能**: 显示临时提示信息
+
+**成功提示**:
+
+```
+┌─────────────────────────────────────┐
+│ [成功图标] 数据生成成功             │
+└─────────────────────────────────────┘
+```
+
+**警告提示**:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ [警告图标] 有 2 个字段生成失败：phone、email               │
+└─────────────────────────────────────────────────────────────┘
+```
+
+**错误提示**:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ [错误图标] 生成失败：生成器 "xxx" 不存在                   │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+### 6.2 Modal 提示组件
+
+**功能**: 显示严重错误的模态框
+
+**错误模态框**:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                                                             │
+│  ┌───────────────────────────────────────────────────────┐ │
+│  │                                                       │ │
+│  │  [错误图标] 生成失败                                  │ │
+│  │                                                       │ │
+│  │  字段 "phone" 的生成器 "chinesePhone1" 不存在        │ │
+│  │                                                       │ │
+│  │  请检查字段配置中的生成器名称是否正确                 │ │
+│  │                                                       │ │
+│  │  ─────────────────────────────────────────────────── │ │
+│  │                                                       │ │
+│  │                    [ 确定 ]                           │ │
+│  │                                                       │ │
+│  └───────────────────────────────────────────────────────┘ │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+### 7. 规则管理组件
+
+**功能**: 管理已保存的规则
+
+**界面**:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  规则管理                                                         │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  搜索: [搜索规则名称...                                          ] │
+│                                                                     │
+│  规则列表:                                                        │
+│  ┌───────────────────────────────────────────────────────────────┐ │
+│  │ 电商用户数据 - 测试用                                       │ │
+│  │    用于测试用户注册功能                                     │ │
+│  │    4 个字段 | 100 条 | JSON                                │ │
+│  │    2024-01-15 创建 | 使用 12 次                           │ │
+│  │    [加载]  [编辑]  [导出]  [删除]                 │ │
+│  │                                                               │ │
+│  │ 电商订单数据 - 测试用                                       │ │
+│  │    用于测试订单功能                                         │ │
+│  │    6 个字段 | 500 条 | JSON                                │ │
+│  │    2024-01-16 创建 | 使用 8 次                            │ │
+│  │    [加载]  [编辑]  [导出]  [删除]                 │ │
+│  └───────────────────────────────────────────────────────────────┘ │
+│                                                                     │
+│  [导入规则]  [导出全部]                                        │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 响应式设计
+
+### 桌面端 (>1024px)
+
+- 左右分栏布局
+- 字段配置区占 60%
+- 数据预览区占 40%
+
+---
+
+## 交互细节
+
+### 拖拽排序
+
+- 字段支持拖拽排序（基于 @dnd-kit/sortable）
+- 拖拽手柄（GripVertical 图标）位于字段左侧
+- 拖拽时显示半透明效果和阴影
+- 释放后立即生效，自动更新字段顺序
+
+### 实时预览
+
+- 配置参数时实时更新预览
+- 延迟 300ms 防抖，避免频繁重渲染
+- 预览最多显示 10 条示例数据
+- 生成完成后切换为完整结果预览
+
+### 虚拟列表
+
+- 数据量超过 100 条时自动启用虚拟滚动
+- 仅渲染可见区域的行，大幅减少 DOM 节点
+- 行高固定 20px，支持快速滚动
+
+---
+
+## 主题支持
+
+### 浅色主题
+
+- 背景色: #ffffff
+- 文字色: #333333
+- 边框色: #e0e0e0
+- 主题色: #3b82f6
+
+### 深色主题
+
+- 背景色: #1a1a1a
+- 文字色: #ffffff
+- 边框色: #404040
+- 主题色: #60a5fa

i18n/README.md

@@ -1,61 +0,0 @@
-# i18n/
-
-国际化资源目录，管理多语言翻译和 i18next 初始化配置。
-
-## 目录结构
-
-```
-i18n/
-├── index.ts                    # i18next 初始化配置
-└── locales/
-    ├── zh/                     # 中文翻译（默认语言）
-    │   ├── common.json         # 通用文案
-    │   ├── features.json       # 功能模块标题和描述
-    │   ├── timestamp.json      # 时间戳工具翻译
-    │   ├── storageCleaner.json # 存储清理工具翻译
-    │   ├── qrCode.json         # 二维码工具翻译
-    │   ├── textStatistics.json # 文本统计工具翻译
-    │   ├── jwt.json            # JWT 工具翻译
-    │   ├── jsonDiff.json       # JSON 差异工具翻译
-    │   ├── jsonFormat.json     # JSON 格式化工具翻译
-    │   ├── base64Converter.json
-    │   ├── markdownToHtml.json
-    │   ├── htmlToMarkdown.json
-    │   └── rightClickRestorer.json
-    └── en/                     # 英文翻译（结构同上）
-        └── ...
-```
-
-## index.ts
-
-i18next 初始化配置：
-
-- 同步加载 `common` 和 `features` 核心命名空间
-- 自定义 `chromeStorage` 语言检测器，从 Chrome Storage 读取语言偏好
-- `normalizeLanguage()` 将任意语言标识归一化为 `zh` 或 `en`
-- 语言变更时同步更新 Day.js 本地化和 localStorage 快照
-
-## 翻译键格式
-
-- 命名空间：`common`（默认）、`features`、各功能独立命名空间
-- 键格式：`namespace:key`（如 `features:timestamp.title`、`timestamp:unitMs`）
-
-## 使用方式
-
-```tsx
-// 页面组件 — 懒加载翻译
-import { useLazyTranslation } from '@/utils/useLazyTranslation';
-const { t } = useLazyTranslation('timestamp');
-t('timestamp:title');
-
-// 全局组件 — 直接使用
-import { useTranslation } from 'react-i18next';
-const { t } = useTranslation(['common', 'features']);
-t('common:settings');
-```
-
-## 添加新翻译
-
-1. 在 `locales/{zh,en}/features.json` 添加功能标题和描述
-2. 创建 `locales/{zh,en}/{功能名}.json` 添加功能专属翻译
-3. 在 `utils/useLazyTranslation.ts` 的 `localeModules` 中注册新命名空间

lint-staged.config.mjs

@@ -1,4 +1,12 @@
+/* global process */
+
+const isCI = process.env.CI === 'true';
+
 export default {
-  '*.{ts,tsx,js,jsx,mjs}': ['eslint --fix --max-warnings=0 --no-warn-ignored', 'prettier --write'],
+  '*.{ts,tsx,js,jsx,mjs}': [
+    'eslint --fix --no-warn-ignored',
+    ...(isCI ? ['eslint --max-warnings=0'] : []),
+    'prettier --write',
+  ],
   '*.{json,css,scss,md}': ['prettier --write'],
 };

public/README.md

@@ -12,9 +12,24 @@
 | `icon/48.png`  | 48×48 图标（扩展管理页）         |
 | `icon/96.png`  | 96×96 图标                       |
 | `icon/128.png` | 128×128 图标（Chrome Web Store） |
-| `wxt.svg`      | WXT 框架标志 SVG 图标            |
+| `_locales/`    | Chrome 扩展本地化资源            |
+
+## 本地化资源
+
+项目使用 Chrome 扩展标准 `chrome.i18n`，默认语言在 `wxt.config.ts` 中配置为 `zh_CN`。
+
+| 文件/目录                      | 用途                                               |
+| ------------------------------ | -------------------------------------------------- |
+| `_locales/zh_CN/messages.json` | 默认中文语言包，包含功能名、描述、按钮、提示等翻译 |
+
+添加或修改文案时：
+
+- 使用 Chrome 扩展消息格式：`"key": { "message": "文本" }`
+- key 使用下划线分隔，例如 `testDataGenerator_title`
+- 代码中通过 `useI18n` 或 `getMessage` 读取，不要新增 `i18n/locales` 目录
 
 ## 注意事项
 
 - 修改图标后需同步更新 `wxt.config.ts` 中的 manifest 配置
 - 图标格式推荐使用 PNG，确保透明背景
+- 修改 `_locales` 后需确认 `manifest.default_locale` 与语言目录名一致

public/_locales/zh_CN/messages.json

@@ -7,7 +7,6 @@
     "message": "清理",
     "description": "Translation key: buttons_clear"
   },
-
   "messages_copySuccess": {
     "message": "已复制到剪贴板",
     "description": "Translation key: messages_copySuccess"
@@ -576,6 +575,50 @@
     "message": "点击更换图片",
     "description": "Translation key: qrCode_clickToChange"
   },
+  "qrCode_generateButton": {
+    "message": "生成二维码",
+    "description": "Translation key: qrCode_generateButton"
+  },
+  "qrCode_editButton": {
+    "message": "编辑",
+    "description": "Translation key: qrCode_editButton"
+  },
+  "qrCode_textPreviewLabel": {
+    "message": "原始文本",
+    "description": "Translation key: qrCode_textPreviewLabel"
+  },
+  "qrCode_generateFirstHint": {
+    "message": "输入文本后点击「生成二维码」按钮",
+    "description": "Translation key: qrCode_generateFirstHint"
+  },
+  "qrCode_inputRequired": {
+    "message": "请输入内容",
+    "description": "Translation key: qrCode_inputRequired"
+  },
+  "qrCode_generateError": {
+    "message": "生成二维码失败，请重试",
+    "description": "Translation key: qrCode_generateError"
+  },
+  "qrCode_uploadedImage": {
+    "message": "已上传图片",
+    "description": "Translation key: qrCode_uploadedImage"
+  },
+  "qrCode_reuploadButton": {
+    "message": "重新上传",
+    "description": "Translation key: qrCode_reuploadButton"
+  },
+  "qrCode_parsing": {
+    "message": "解析中...",
+    "description": "Translation key: qrCode_parsing"
+  },
+  "qrCode_resultPlaceholder": {
+    "message": "解析结果将显示在此处",
+    "description": "Translation key: qrCode_resultPlaceholder"
+  },
+  "qrCode_imageToQr": {
+    "message": "解析图片二维码",
+    "description": "Translation key: qrCode_imageToQr"
+  },
   "rightClickRestorer_loading": {
     "message": "正在加载...",
     "description": "Translation key: rightClickRestorer_loading"
@@ -697,7 +740,7 @@
     "description": "Translation key: storageCleaner_options_sessionStorage"
   },
   "storageCleaner_options_indexedDB": {
-    "message": "IndexedDB",
+    "message": "站点存储",
     "description": "Translation key: storageCleaner_options_indexedDB"
   },
   "storageCleaner_options_cookies": {
@@ -760,6 +803,10 @@
     "message": "毫秒 (ms)",
     "description": "Translation key: timestamp_unitMs"
   },
+  "timestamp_unitS": {
+    "message": "秒 (s)",
+    "description": "Translation key: timestamp_unitS"
+  },
   "timestamp_currentTs": {
     "message": "当前时间戳",
     "description": "Translation key: timestamp_currentTs"
@@ -848,7 +895,6 @@
     "message": "在标签页打开",
     "description": "Translation key: buttons_openInTab"
   },
-
   "common_errorBoundary_title": {
     "message": "糟糕，出了点问题",
     "description": "Translation key: errorBoundary_title"
@@ -872,5 +918,387 @@
   "common_pageErrorBoundary_description": {
     "message": "该页面在加载或渲染时遇到了内部脚本错误。您可以尝试重试，或者通过导航菜单切换到其他工具。",
     "description": "Translation key: pageErrorBoundary_description"
+  },
+  "testDataGenerator_title": {
+    "message": "测试数据生成器",
+    "description": "Translation key: testDataGenerator_title"
+  },
+  "testDataGenerator_description": {
+    "message": "自定义字段配置，批量生成测试数据",
+    "description": "Translation key: testDataGenerator_description"
+  },
+  "testDataGenerator_fields": {
+    "message": "字段",
+    "description": "Translation key: testDataGenerator_fields"
+  },
+  "testDataGenerator_addField": {
+    "message": "添加字段",
+    "description": "Translation key: testDataGenerator_addField"
+  },
+  "testDataGenerator_noFields": {
+    "message": "暂无字段",
+    "description": "Translation key: testDataGenerator_noFields"
+  },
+  "testDataGenerator_addFieldHint": {
+    "message": "点击上方按钮添加第一个字段",
+    "description": "Translation key: testDataGenerator_addFieldHint"
+  },
+  "testDataGenerator_unique": {
+    "message": "唯一",
+    "description": "Translation key: testDataGenerator_unique"
+  },
+  "testDataGenerator_fieldName": {
+    "message": "字段名称",
+    "description": "Translation key: testDataGenerator_fieldName"
+  },
+  "testDataGenerator_fieldNamePlaceholder": {
+    "message": "请输入字段名称",
+    "description": "Translation key: testDataGenerator_fieldNamePlaceholder"
+  },
+  "testDataGenerator_fieldDescription": {
+    "message": "字段描述",
+    "description": "Translation key: testDataGenerator_fieldDescription"
+  },
+  "testDataGenerator_fieldDescriptionPlaceholder": {
+    "message": "可选，添加字段说明",
+    "description": "Translation key: testDataGenerator_fieldDescriptionPlaceholder"
+  },
+  "testDataGenerator_required": {
+    "message": "必填",
+    "description": "Translation key: testDataGenerator_required"
+  },
+  "testDataGenerator_nullRate": {
+    "message": "空值率",
+    "description": "Translation key: testDataGenerator_nullRate"
+  },
+  "testDataGenerator_uniqueConstraint": {
+    "message": "唯一性约束",
+    "description": "Translation key: testDataGenerator_uniqueConstraint"
+  },
+  "testDataGenerator_generator": {
+    "message": "数据生成器",
+    "description": "Translation key: testDataGenerator_generator"
+  },
+  "testDataGenerator_generatorParams": {
+    "message": "生成器参数",
+    "description": "Translation key: testDataGenerator_generatorParams"
+  },
+  "testDataGenerator_searchGenerator": {
+    "message": "搜索生成器...",
+    "description": "Translation key: testDataGenerator_searchGenerator"
+  },
+  "testDataGenerator_searchResults": {
+    "message": "搜索结果",
+    "description": "Translation key: testDataGenerator_searchResults"
+  },
+  "testDataGenerator_fieldConfig": {
+    "message": "字段配置",
+    "description": "Translation key: testDataGenerator_fieldConfig"
+  },
+  "testDataGenerator_ruleManagement": {
+    "message": "规则管理",
+    "description": "Translation key: testDataGenerator_ruleManagement"
+  },
+  "testDataGenerator_selectFieldToEdit": {
+    "message": "选择左侧字段进行编辑",
+    "description": "Translation key: testDataGenerator_selectFieldToEdit"
+  },
+  "testDataGenerator_count": {
+    "message": "生成数量",
+    "description": "Translation key: testDataGenerator_count"
+  },
+  "testDataGenerator_format": {
+    "message": "数据格式",
+    "description": "Translation key: testDataGenerator_format"
+  },
+  "testDataGenerator_generate": {
+    "message": "生成数据",
+    "description": "Translation key: testDataGenerator_generate"
+  },
+  "testDataGenerator_cancel": {
+    "message": "取消",
+    "description": "Translation key: testDataGenerator_cancel"
+  },
+  "testDataGenerator_progress": {
+    "message": "已生成 {{current}} / {{total}} 条",
+    "description": "Translation key: testDataGenerator_progress"
+  },
+  "testDataGenerator_estimatedTime": {
+    "message": "预计剩余 {{time}} 秒",
+    "description": "Translation key: testDataGenerator_estimatedTime"
+  },
+  "testDataGenerator_dataPreview": {
+    "message": "数据预览",
+    "description": "Translation key: testDataGenerator_dataPreview"
+  },
+  "testDataGenerator_noData": {
+    "message": "暂无数据",
+    "description": "Translation key: testDataGenerator_noData"
+  },
+  "testDataGenerator_noDataHint": {
+    "message": "配置字段后点击「生成数据」按钮",
+    "description": "Translation key: testDataGenerator_noDataHint"
+  },
+  "testDataGenerator_sampleData": {
+    "message": "示例数据",
+    "description": "Translation key: testDataGenerator_sampleData"
+  },
+  "testDataGenerator_copied": {
+    "message": "已复制",
+    "description": "Translation key: testDataGenerator_copied"
+  },
+  "testDataGenerator_copy": {
+    "message": "复制",
+    "description": "Translation key: testDataGenerator_copy"
+  },
+  "testDataGenerator_pageInfo": {
+    "message": "第 {{current}} / {{total}} 页",
+    "description": "Translation key: testDataGenerator_pageInfo"
+  },
+  "testDataGenerator_prevPage": {
+    "message": "上一页",
+    "description": "Translation key: testDataGenerator_prevPage"
+  },
+  "testDataGenerator_nextPage": {
+    "message": "下一页",
+    "description": "Translation key: testDataGenerator_nextPage"
+  },
+  "testDataGenerator_success": {
+    "message": "生成成功",
+    "description": "Translation key: testDataGenerator_success"
+  },
+  "testDataGenerator_generateSuccess": {
+    "message": "生成完成",
+    "description": "Translation key: testDataGenerator_generateSuccess"
+  },
+  "testDataGenerator_records": {
+    "message": "条数据",
+    "description": "Translation key: testDataGenerator_records"
+  },
+  "testDataGenerator_partialSuccess": {
+    "message": "部分成功",
+    "description": "Translation key: testDataGenerator_partialSuccess"
+  },
+  "testDataGenerator_failed": {
+    "message": "生成失败",
+    "description": "Translation key: testDataGenerator_failed"
+  },
+  "testDataGenerator_totalCount": {
+    "message": "总条数",
+    "description": "Translation key: testDataGenerator_totalCount"
+  },
+  "testDataGenerator_successCount": {
+    "message": "成功",
+    "description": "Translation key: testDataGenerator_successCount"
+  },
+  "testDataGenerator_duration": {
+    "message": "耗时",
+    "description": "Translation key: testDataGenerator_duration"
+  },
+  "testDataGenerator_warnings": {
+    "message": "警告",
+    "description": "Translation key: testDataGenerator_warnings"
+  },
+  "testDataGenerator_moreWarnings": {
+    "message": "还有 {{count}} 条警告",
+    "description": "Translation key: testDataGenerator_moreWarnings"
+  },
+  "testDataGenerator_export": {
+    "message": "导出数据",
+    "description": "Translation key: testDataGenerator_export"
+  },
+  "testDataGenerator_copyJSON": {
+    "message": "复制 JSON",
+    "description": "Translation key: testDataGenerator_copyJSON"
+  },
+  "testDataGenerator_copyCSV": {
+    "message": "复制 CSV",
+    "description": "Translation key: testDataGenerator_copyCSV"
+  },
+  "testDataGenerator_downloadJSON": {
+    "message": "下载 JSON",
+    "description": "Translation key: testDataGenerator_downloadJSON"
+  },
+  "testDataGenerator_downloadCSV": {
+    "message": "下载 CSV",
+    "description": "Translation key: testDataGenerator_downloadCSV"
+  },
+  "testDataGenerator_saveRule": {
+    "message": "保存规则",
+    "description": "Translation key: testDataGenerator_saveRule"
+  },
+  "testDataGenerator_import": {
+    "message": "导入",
+    "description": "Translation key: testDataGenerator_import"
+  },
+  "testDataGenerator_exportRules": {
+    "message": "导出规则",
+    "description": "Translation key: testDataGenerator_exportRules"
+  },
+  "testDataGenerator_ruleCount": {
+    "message": "已保存 {{count}}/{{max}} 条",
+    "description": "Translation key: testDataGenerator_ruleCount"
+  },
+  "testDataGenerator_searchRules": {
+    "message": "搜索规则...",
+    "description": "Translation key: testDataGenerator_searchRules"
+  },
+  "testDataGenerator_saveNewRule": {
+    "message": "保存新规则",
+    "description": "Translation key: testDataGenerator_saveNewRule"
+  },
+  "testDataGenerator_ruleNamePlaceholder": {
+    "message": "规则名称",
+    "description": "Translation key: testDataGenerator_ruleNamePlaceholder"
+  },
+  "testDataGenerator_ruleDescPlaceholder": {
+    "message": "规则描述（可选）",
+    "description": "Translation key: testDataGenerator_ruleDescPlaceholder"
+  },
+  "testDataGenerator_confirm": {
+    "message": "确认",
+    "description": "Translation key: testDataGenerator_confirm"
+  },
+  "testDataGenerator_done": {
+    "message": "完成",
+    "description": "Translation key: testDataGenerator_done"
+  },
+  "testDataGenerator_noSearchResults": {
+    "message": "未找到匹配的规则",
+    "description": "Translation key: testDataGenerator_noSearchResults"
+  },
+  "testDataGenerator_noRules": {
+    "message": "暂无保存的规则",
+    "description": "Translation key: testDataGenerator_noRules"
+  },
+  "testDataGenerator_usedTimes": {
+    "message": "使用 {{count}} 次",
+    "description": "Translation key: testDataGenerator_usedTimes"
+  },
+  "testDataGenerator_load": {
+    "message": "加载",
+    "description": "Translation key: testDataGenerator_load"
+  },
+  "testDataGenerator_duplicate": {
+    "message": "复制",
+    "description": "Translation key: testDataGenerator_duplicate"
+  },
+  "testDataGenerator_delete": {
+    "message": "删除",
+    "description": "Translation key: testDataGenerator_delete"
+  },
+  "testDataGenerator_virtualMode": {
+    "message": "虚拟列表模式（共 $ 行）"
+  },
+  "testDataGenerator_totalRows": {
+    "message": "共 $ 条数据"
+  },
+  "testDataGenerator_ruleSaved": {
+    "message": "规则已保存",
+    "description": "Translation key: testDataGenerator_ruleSaved"
+  },
+  "testDataGenerator_ruleLoaded": {
+    "message": "已加载规则「{{name}}」",
+    "description": "Translation key: testDataGenerator_ruleLoaded"
+  },
+  "testDataGenerator_ruleDeleted": {
+    "message": "规则已删除",
+    "description": "Translation key: testDataGenerator_ruleDeleted"
+  },
+  "testDataGenerator_ruleDuplicated": {
+    "message": "规则已复制",
+    "description": "Translation key: testDataGenerator_ruleDuplicated"
+  },
+  "testDataGenerator_exportSuccess": {
+    "message": "规则已导出",
+    "description": "Translation key: testDataGenerator_exportSuccess"
+  },
+  "testDataGenerator_importSuccess": {
+    "message": "成功导入 {{count}} 条规则",
+    "description": "Translation key: testDataGenerator_importSuccess"
+  },
+  "testDataGenerator_importFailed": {
+    "message": "{{count}} 条规则导入失败",
+    "description": "Translation key: testDataGenerator_importFailed"
+  },
+  "testDataGenerator_confirmDeleteTitle": {
+    "message": "确认删除规则",
+    "description": "Translation key: testDataGenerator_confirmDeleteTitle"
+  },
+  "testDataGenerator_confirmDeleteDescription": {
+    "message": "确定要删除规则「{{name}}」吗？此操作不可撤销。",
+    "description": "Translation key: testDataGenerator_confirmDeleteDescription"
+  },
+  "testDataGenerator_ruleNameDuplicate": {
+    "message": "已存在同名规则，是否覆盖保存？",
+    "description": "Translation key: testDataGenerator_ruleNameDuplicate"
+  },
+  "testDataGenerator_overwrite": {
+    "message": "覆盖",
+    "description": "Translation key: testDataGenerator_overwrite"
+  },
+  "testDataGenerator_edit": {
+    "message": "编辑",
+    "description": "Translation key: testDataGenerator_edit"
+  },
+  "testDataGenerator_ruleUpdated": {
+    "message": "规则已更新",
+    "description": "Translation key: testDataGenerator_ruleUpdated"
+  },
+  "testDataGenerator_editing": {
+    "message": "编辑中",
+    "description": "Translation key: testDataGenerator_editing"
+  },
+  "testDataGenerator_editingRule": {
+    "message": "正在编辑规则「{{name}}」",
+    "description": "Translation key: testDataGenerator_editingRule"
+  },
+  "testDataGenerator_updateRule": {
+    "message": "更新规则",
+    "description": "Translation key: testDataGenerator_updateRule"
+  },
+  "testDataGenerator_saveAs": {
+    "message": "另存为",
+    "description": "Translation key: testDataGenerator_saveAs"
+  },
+  "testDataGenerator_noGeneratorParams": {
+    "message": "此生成器无可配置参数",
+    "description": "Translation key: testDataGenerator_noGeneratorParams"
+  },
+  "testDataGenerator_enabled": {
+    "message": "启用",
+    "description": "Translation key: testDataGenerator_enabled"
+  },
+  "testDataGenerator_disabled": {
+    "message": "禁用",
+    "description": "Translation key: testDataGenerator_disabled"
+  },
+  "testDataGenerator_commaSeparated": {
+    "message": "用逗号分隔多个值",
+    "description": "Translation key: testDataGenerator_commaSeparated"
+  },
+  "testDataGenerator_copySuccess": {
+    "message": "已复制到剪贴板",
+    "description": "Translation key: testDataGenerator_copySuccess"
+  },
+  "testDataGenerator_copyFailed": {
+    "message": "复制失败",
+    "description": "Translation key: testDataGenerator_copyFailed"
+  },
+  "testDataGenerator_fieldNameEmpty": {
+    "message": "字段名称不能为空",
+    "description": "Translation key: testDataGenerator_fieldNameEmpty"
+  },
+  "testDataGenerator_fieldNameDuplicate": {
+    "message": "字段名称已存在",
+    "description": "Translation key: testDataGenerator_fieldNameDuplicate"
+  },
+  "testDataGenerator_fieldNameInvalid": {
+    "message": "字段名称只能包含字母、数字和下划线",
+    "description": "Translation key: testDataGenerator_fieldNameInvalid"
+  },
+  "testDataGenerator_ruleCopySuffix": {
+    "message": "（副本）",
+    "description": "Translation key: testDataGenerator_ruleCopySuffix"
   }
 }

src/components/CopyButton.tsx

@@ -53,6 +53,7 @@ export const CopyButton: React.FC<CopyButtonProps> = ({
       type="button"
       onClick={handleCopy}
       title={tooltip ?? t('buttons.copy')}
+      aria-label={tooltip ?? t('buttons.copy')}
       className={cn(
         buttonVariants({ variant, size }),
         copied &&
@@ -62,7 +63,7 @@ export const CopyButton: React.FC<CopyButtonProps> = ({
       {...props}
     >
       {copied ? (
-        <Check className="h-[1.2em] w-[1.2em] animate-in fade-in zoom-in-75 duration-200" />
+        <Check className="h-[1.2em] w-[1.2em]" />
       ) : (
         <Copy className="h-[1.2em] w-[1.2em]" />
       )}

src/components/CopyButton/__tests__/index.test.tsx

@@ -0,0 +1,194 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { act, render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+// unmock the globally-mocked component so we test the real implementation
+vi.unmock('@/components/CopyButton');
+
+vi.mock('@/utils/clipboard', () => ({
+  copyTextToClipboard: vi.fn(),
+}));
+
+vi.mock('sonner', () => ({
+  toast: {
+    success: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+import { CopyButton } from '@/components/CopyButton';
+import { copyTextToClipboard } from '@/utils/clipboard';
+import { toast } from 'sonner';
+
+const mockedCopy = vi.mocked(copyTextToClipboard);
+const mockedToast = vi.mocked(toast);
+
+describe('CopyButton', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('复制成功时调用 copyTextToClipboard 并传入正确 text', async () => {
+    mockedCopy.mockResolvedValue(true);
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+
+    render(<CopyButton text="hello world" />);
+
+    await user.click(screen.getByRole('button'));
+
+    expect(mockedCopy).toHaveBeenCalledWith('hello world');
+    expect(mockedToast.success).toHaveBeenCalled();
+  });
+
+  it('复制成功后图标切换为 Check，1.5 秒后恢复', async () => {
+    mockedCopy.mockResolvedValue(true);
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+
+    render(<CopyButton text="test" />);
+
+    // 点击后复制成功，按钮获得 emerald 样式（说明切到了 Check 状态）
+    await user.click(screen.getByRole('button'));
+
+    await waitFor(() => {
+      expect(screen.getByRole('button').className).toContain('text-emerald');
+    });
+
+    // 1.5 秒后样式恢复
+    act(() => {
+      vi.advanceTimersByTime(1500);
+    });
+
+    await waitFor(() => {
+      expect(screen.getByRole('button').className).not.toContain('text-emerald');
+    });
+  });
+
+  it('复制空文本时弹出 error toast', async () => {
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+
+    render(<CopyButton text="" />);
+
+    await user.click(screen.getByRole('button'));
+
+    expect(mockedCopy).not.toHaveBeenCalled();
+    expect(mockedToast.error).toHaveBeenCalled();
+  });
+
+  it('复制失败时弹出 error toast', async () => {
+    mockedCopy.mockResolvedValue(false);
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+
+    render(<CopyButton text="something" />);
+
+    await user.click(screen.getByRole('button'));
+
+    expect(mockedCopy).toHaveBeenCalledWith('something');
+    expect(mockedToast.error).toHaveBeenCalled();
+  });
+
+  // ==================== 新增测试 ====================
+
+  it('初始渲染时显示 Copy 图标且无 emerald 样式', () => {
+    render(<CopyButton text="initial" />);
+
+    const button = screen.getByRole('button');
+    expect(button.className).not.toContain('text-emerald');
+    // 通过 aria-label 确认按钮存在，图标由 lucide 渲染为 svg
+    expect(button).toHaveAttribute('aria-label');
+  });
+
+  it('自定义 tooltip 会覆盖默认 title 和 aria-label', () => {
+    render(<CopyButton text="tooltip-test" tooltip="自定义提示" />);
+
+    const button = screen.getByRole('button');
+    expect(button).toHaveAttribute('title', '自定义提示');
+    expect(button).toHaveAttribute('aria-label', '自定义提示');
+  });
+
+  it('className 被正确透传到按钮', () => {
+    render(<CopyButton text="class-test" className="my-custom-class" />);
+
+    const button = screen.getByRole('button');
+    expect(button.className).toContain('my-custom-class');
+  });
+
+  it('点击事件阻止冒泡', async () => {
+    mockedCopy.mockResolvedValue(true);
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+    const parentClick = vi.fn();
+
+    render(
+      <div onClick={parentClick}>
+        <CopyButton text="stop-propagation" />
+      </div>,
+    );
+
+    await user.click(screen.getByRole('button'));
+
+    expect(mockedCopy).toHaveBeenCalled();
+    expect(parentClick).not.toHaveBeenCalled();
+  });
+
+  it('组件卸载时清除定时器，不触发状态更新警告', async () => {
+    mockedCopy.mockResolvedValue(true);
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+
+    const { unmount } = render(<CopyButton text="unmount-test" />);
+
+    await user.click(screen.getByRole('button'));
+
+    // 在 1.5 秒超时到期前卸载组件
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
+
+    // 卸载不应抛出 "Can't perform a React state update on an unmounted component" 警告
+    expect(() => unmount()).not.toThrow();
+
+    // 前进剩余时间，确认没有异常
+    act(() => {
+      vi.advanceTimersByTime(2000);
+    });
+  });
+
+  it('快速连续点击不会创建多个重叠定时器', async () => {
+    mockedCopy.mockResolvedValue(true);
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+
+    render(<CopyButton text="rapid-click" />);
+
+    const button = screen.getByRole('button');
+
+    // 快速点击 3 次
+    await user.click(button);
+    await user.click(button);
+    await user.click(button);
+
+    // copyTextToClipboard 应该被调用 3 次（每次点击都执行）
+    expect(mockedCopy).toHaveBeenCalledTimes(3);
+
+    // 但 setTimeout 相关的 clearTimeout + setTimeout 组合应正常工作
+    //  advance 1.5 秒后，copied 状态应恢复为 false
+    act(() => {
+      vi.advanceTimersByTime(1500);
+    });
+
+    await waitFor(() => {
+      expect(button.className).not.toContain('text-emerald');
+    });
+  });
+
+  it('其他 button props 通过 ...props 透传', () => {
+    render(<CopyButton text="props-test" data-testid="copy-btn" disabled id="copy-button-id" />);
+
+    const button = screen.getByRole('button');
+    expect(button).toHaveAttribute('data-testid', 'copy-btn');
+    expect(button).toBeDisabled();
+    expect(button).toHaveAttribute('id', 'copy-button-id');
+  });
+});

src/components/GlobalSnackbar.tsx

@@ -1,372 +0,0 @@
-/**
- * GlobalSnackbar - 全局 Snackbar 消息提示组件及 Provider
- *
- * 提供可复用的 Toast 消息提示功能，支持三种使用方式：
- * 1. 作为受控组件使用：通过 props 控制显示状态
- * 2. 通过 useSnackbarState Hook 使用：在组件内部自动管理状态
- * 3. 通过 SnackbarProvider 和 useSnackbar Hook 使用：全局单例模式
- *
- * NOTE: 项目同时使用 sonner 的 toast 进行简单的一次性提示。
- * 本组件适用于需要 severity 级别、Provider 上下文、自定义定位等高级场景。
- * 简单场景（如复制成功、操作提示）优先使用 `import { toast } from 'sonner'`。
- *
- * @module GlobalSnackbar
- * @version 1.1.0
- *
- * @example
- * ```tsx
- * // 方式一：受控组件
- * <GlobalSnackbar
- *   message="操作成功"
- *   open={isOpen}
- *   onClose={() => setIsOpen(false)}
- *   severity="success"
- * />
- *
- * // 方式二：Hook 方式 (局部状态)
- * const { snackbarProps, showMessage } = useSnackbarState();
- * showMessage('Hello!', { severity: 'info' });
- *
- * // 方式三：Context 方式 (全局状态)
- * // 在根组件包裹 Provider
- * <SnackbarProvider>
- *   <App />
- * </SnackbarProvider>
- *
- * // 在子组件中使用
- * const { showMessage } = useSnackbar();
- * showMessage('Global Message');
- * ```
- */
-
-import {
-  JSX,
-  useState,
-  useRef,
-  createContext,
-  useContext,
-  useEffect,
-  type ReactNode,
-  type SyntheticEvent,
-} from 'react';
-import { CheckCircle, Info, AlertTriangle, XCircle } from 'lucide-react';
-
-/**
- * Snackbar 消息严重程度类型
- * @description 决定 Alert 组件的颜色和图标
- * - success: 绿色，成功提示
- * - info: 蓝色，信息提示
- * - warning: 橙色，警告提示
- * - error: 红色，错误提示
- */
-export type SnackbarSeverity = 'success' | 'info' | 'warning' | 'error';
-
-/**
- * GlobalSnackbar 组件的属性接口
- * @interface GlobalSnackbarProps
- */
-export interface GlobalSnackbarProps {
-  /** 消息内容，要显示的提示文本 */
-  message: string;
-  /** 是否显示 Snackbar */
-  open: boolean;
-  /** 关闭回调函数 */
-  onClose: () => void;
-  /** 消息级别，影响颜色和图标样式，默认 'info' */
-  severity?: SnackbarSeverity;
-  /** 自动隐藏时间（毫秒），设为 0 则不自动关闭，默认 2000 */
-  autoHideDuration?: number;
-  /** Snackbar 弹出位置，默认 { vertical: 'bottom', horizontal: 'center' } */
-  anchorOrigin?: {
-    vertical: 'top' | 'bottom';
-    horizontal: 'left' | 'center' | 'right';
-  };
-  /** 是否使用 Alert 组件包裹，false 则使用原生 Snackbar message，默认 true */
-  showAlert?: boolean;
-  /** 是否隐藏 Alert 图标，默认 false */
-  hideIcon?: boolean;
-  /** 自定义样式，透传给外层 Snackbar 组件 */
-  sx?: React.CSSProperties;
-  /** 自定义样式，透传给内层 Alert 组件（仅 showAlert=true 时生效） */
-  alertSx?: React.CSSProperties;
-}
-
-/**
- * showMessage 方法的选项配置
- * @interface SnackbarOptions
- */
-export interface SnackbarOptions {
-  /** 消息级别：success | info | warning | error */
-  severity?: SnackbarSeverity;
-  /** 自动隐藏时间（毫秒），设为 0 则不自动关闭 */
-  autoHideDuration?: number;
-  /** 是否隐藏 Alert 图标 */
-  hideIcon?: boolean;
-  /** 是否使用 Alert 组件包裹 */
-  showAlert?: boolean;
-}
-
-/**
- * useSnackbarState Hook 的返回值类型
- * @interface UseSnackbarStateResult
- */
-export interface UseSnackbarStateResult {
-  /** 传递给 GlobalSnackbar 组件的属性对象 */
-  snackbarProps: GlobalSnackbarProps;
-  /** 显示消息的方法 */
-  showMessage: (message: string, options?: SnackbarOptions) => void;
-  /** 关闭消息的方法 */
-  closeMessage: () => void;
-}
-
-/**
- * GlobalSnackbar 组件的默认属性配置
- * @description 提供类型安全的默认值选择
- */
-const defaultProps: Required<
-  Pick<
-    GlobalSnackbarProps,
-    'severity' | 'autoHideDuration' | 'anchorOrigin' | 'showAlert' | 'hideIcon'
-  >
-> = {
-  severity: 'info',
-  autoHideDuration: 2000,
-  anchorOrigin: { vertical: 'bottom', horizontal: 'center' },
-  showAlert: true,
-  hideIcon: false,
-};
-
-const severityConfig: Record<
-  SnackbarSeverity,
-  { icon: React.ElementType; bgClass: string; textClass: string }
-> = {
-  success: { icon: CheckCircle, bgClass: 'bg-green-500', textClass: 'text-white' },
-  info: { icon: Info, bgClass: 'bg-primary/100', textClass: 'text-white' },
-  warning: { icon: AlertTriangle, bgClass: 'bg-amber-500', textClass: 'text-white' },
-  error: { icon: XCircle, bgClass: 'bg-red-500', textClass: 'text-white' },
-};
-
-/**
- * GlobalSnackbar 组件
- *
- * 全局消息提示的展示组件，支持受控和非受控两种使用模式。
- *
- * @param {GlobalSnackbarProps} props - 组件属性
- * @returns {JSX.Element}
- */
-export function GlobalSnackbar({
-  message,
-  open,
-  onClose,
-  severity = defaultProps.severity,
-  autoHideDuration = defaultProps.autoHideDuration,
-  showAlert = defaultProps.showAlert,
-  hideIcon = defaultProps.hideIcon,
-}: GlobalSnackbarProps): JSX.Element | null {
-  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-
-  useEffect(() => {
-    if (open && autoHideDuration > 0) {
-      timerRef.current = setTimeout(() => {
-        onClose();
-      }, autoHideDuration);
-      return () => {
-        if (timerRef.current) clearTimeout(timerRef.current);
-      };
-    }
-    return undefined;
-  }, [open, autoHideDuration, onClose]);
-
-  if (!open) return null;
-
-  const config = severityConfig[severity];
-  const IconComponent = config.icon;
-
-  return (
-    <div className="fixed z-[999999] bottom-6 left-1/2 -translate-x-1/2 animate-in fade-in slide-in-from-bottom-2 duration-300">
-      {showAlert ? (
-        <div
-          className={`flex items-center gap-2 px-5 py-1.5 rounded-full shadow-lg ${config.bgClass} ${config.textClass}`}
-          style={{ minWidth: '140px' }}
-        >
-          {!hideIcon && <IconComponent className="h-4 w-4 flex-shrink-0" />}
-          <span className="text-xs font-bold">{message}</span>
-        </div>
-      ) : (
-        <div className="px-4 py-2 rounded-lg bg-gray-800 text-white text-sm">{message}</div>
-      )}
-    </div>
-  );
-}
-
-/**
- * useSnackbarState - 消息提示的 Hook 方式
- *
- * 提供状态管理的 Snackbar 功能，自动处理 open、message 等状态。
- * 适合在组件内部使用，无需额外的状态管理代码。
- *
- * @param {SnackbarOptions} [initialOptions] - 初始配置选项
- * @returns {UseSnackbarStateResult} 包含 snackbarProps 和操作方法的对象
- *
- * @description
- * - 自动管理 Snackbar 的显示/隐藏状态
- * - 支持链式调用 showMessage
- * - 合并初始选项和调用时选项
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { snackbarProps, showMessage, closeMessage } = useSnackbarState({
- *     severity: 'info',
- *     autoHideDuration: 3000,
- *   });
- *
- *   const handleSave = () => {
- *     // 业务逻辑...
- *     showMessage('保存成功！', { severity: 'success' });
- *   };
- *
- *   return (
- *     <>
- *       <button onClick={handleSave}>保存</button>
- *       <GlobalSnackbar {...snackbarProps} />
- *     </>
- *   );
- * }
- * ```
- */
-export function useSnackbarState(initialOptions?: SnackbarOptions): UseSnackbarStateResult {
-  // Snackbar 显示状态
-  const [open, setOpen] = useState(false);
-  // 当前显示的消息内容
-  const [message, setMessage] = useState('');
-  // 消息配置选项
-  const [options, setOptions] = useState<SnackbarOptions>(initialOptions || {});
-
-  /**
-   * 显示消息
-   *
-   * @param {string} newMessage - 要显示的消息文本
-   * @param {SnackbarOptions} [newOptions={}] - 新的配置选项
-   *
-   * @description
-   * - 合并初始选项和新的调用选项
-   * - 新选项会覆盖初始选项
-   */
-  const showMessage = (newMessage: string, newOptions: SnackbarOptions = {}) => {
-    setMessage(newMessage);
-    setOptions({ ...initialOptions, ...newOptions });
-    setOpen(true);
-  };
-
-  /**
-   * 关闭消息
-   *
-   * @description
-   * - 直接将 open 状态设置为 false
-   */
-  const closeMessage = () => {
-    setOpen(false);
-  };
-
-  const handleClose = (_event?: SyntheticEvent | Event, reason?: string) => {
-    if (reason === 'clickaway') return;
-    closeMessage();
-  };
-
-  /**
-   * 传递给 GlobalSnackbar 组件的属性
-   *
-   * @description
-   * - 组合当前状态和选项为完整的组件 props
-   * - onClose 使用 handleClose 包装后的版本
-   */
-  const snackbarProps: GlobalSnackbarProps = {
-    message,
-    open,
-    onClose: handleClose,
-    severity: options.severity,
-    autoHideDuration: options.autoHideDuration,
-    hideIcon: options.hideIcon,
-  };
-
-  return {
-    snackbarProps,
-    showMessage,
-    closeMessage,
-  };
-}
-
-// --- Context & Provider ---
-
-/**
- * Snackbar Context 的值类型定义
- */
-interface SnackbarContextValue {
-  showMessage: (message: string, options?: SnackbarOptions) => void;
-  closeMessage: () => void;
-}
-
-const SnackbarContext = createContext<SnackbarContextValue | null>(null);
-
-/**
- * SnackbarProvider 组件的 props 类型
- */
-interface SnackbarProviderProps {
-  children: ReactNode;
-  initialOptions?: SnackbarOptions;
-}
-
-/**
- * SnackbarProvider 组件
- *
- * 全局消息提示的 Provider 组件，需要包裹在应用根组件外层。
- */
-export function SnackbarProvider({ children, initialOptions }: SnackbarProviderProps): JSX.Element {
-  const { snackbarProps, showMessage, closeMessage } = useSnackbarState(initialOptions);
-
-  return (
-    <SnackbarContext.Provider value={{ showMessage, closeMessage }}>
-      {children}
-      <GlobalSnackbar {...snackbarProps} />
-    </SnackbarContext.Provider>
-  );
-}
-
-/**
- * useSnackbar - 在子组件中获取 Snackbar 上下文的 Hook
- *
- * @param {SnackbarOptions} [options] - 钩子级别的默认配置（如 autoHideDuration）
- * @returns {SnackbarContextValue} - 包含 showMessage 和 closeMessage 的对象
- * @throws {Error} - 如果不在 SnackbarProvider 内部调用，抛出错误
- *
- * @description
- * 选项合并策略：
- * 1. 调用 showMessage 时传入的 callOptions 优先级最高
- * 2. useSnackbar(options) 传入的 Hook 级别配置次之
- * 3. SnackbarProvider(initialOptions) 传入的全局配置优先级最低
- */
-export function useSnackbar(options?: SnackbarOptions): SnackbarContextValue {
-  const context = useContext(SnackbarContext);
-  if (!context) {
-    throw new Error('useSnackbar must be used within SnackbarProvider');
-  }
-
-  // 包装 showMessage 以支持 Hook 级别的 initialOptions
-  const wrappedShowMessage = (message: string, callOptions?: SnackbarOptions) => {
-    // 采用防御性编程，确保 options 和 callOptions 为空时也能正常工作
-    // 优先级：callOptions > options
-    const mergedOptions: SnackbarOptions = {
-      ...(options || {}),
-      ...(callOptions || {}),
-    };
-    context.showMessage(message, mergedOptions);
-  };
-
-  return {
-    ...context,
-    showMessage: wrappedShowMessage,
-  };
-}
-
-export default GlobalSnackbar;

src/components/ImageUploader.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useRef } from 'react';
 import { Image, X } from 'lucide-react';
-import { useSnackbar } from '@/components/GlobalSnackbar';
+import { toast } from 'sonner';
 import { useI18n } from '@/utils/chromeI18n';
 
 interface ImageUploaderProps {
@@ -30,7 +30,6 @@ const ImageUploader = ({
   onDraggingChange,
 }: ImageUploaderProps) => {
   const { t } = useI18n('qrCode');
-  const { showMessage } = useSnackbar();
   const fileInputRef = useRef<HTMLInputElement>(null);
 
   const handleFileChange = useCallback(
@@ -46,11 +45,8 @@ const ImageUploader = ({
       URL.revokeObjectURL(previewUrl);
     }
     onClearFile();
-    showMessage(t('qrCode:imageCleared'), {
-      severity: 'success',
-      autoHideDuration: 1000,
-    });
-  }, [previewUrl, onClearFile, showMessage, t]);
+    toast.success(t('qrCode:imageCleared'));
+  }, [previewUrl, onClearFile, t]);
 
   const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
     if (e.target.files && e.target.files.length > 0) {
@@ -90,13 +86,10 @@ const ImageUploader = ({
           if (file) {
             try {
               handleFileChange(file);
-              showMessage(t('qrCode:imagePasted'), { severity: 'success', autoHideDuration: 1000 });
+              toast.success(t('qrCode:imagePasted'));
             } catch (error) {
               console.error('处理粘贴图片失败:', error);
-              showMessage(t('qrCode:imagePasteError'), {
-                severity: 'error',
-                autoHideDuration: 3000,
-              });
+              toast.error(t('qrCode:imagePasteError'));
             }
           }
           break;
@@ -109,7 +102,7 @@ const ImageUploader = ({
     return () => {
       document.removeEventListener('paste', handlePaste);
     };
-  }, [showMessage, handleFileChange, t]);
+  }, [handleFileChange, t]);
 
   return (
     <div

src/components/QrCodePreview.tsx

@@ -12,12 +12,15 @@ interface QrCodePreviewProps extends React.HTMLAttributes<HTMLDivElement> {
   onDownload: () => void;
   /** 复制回调 */
   onCopy: () => void;
+  /** 自定义占位文本，用于空状态提示 */
+  placeholderText?: string;
 }
 
 const QrCodePreview = ({
   qrCodeDataUrl,
   onDownload,
   onCopy,
+  placeholderText,
   className,
   ...props
 }: QrCodePreviewProps) => {
@@ -33,7 +36,9 @@ const QrCodePreview = ({
         )}
         {...props}
       >
-        <p className="text-sm text-muted-foreground text-center">{t('qrCode:qrCodeWillShow')}</p>
+        <p className="text-sm text-muted-foreground text-center">
+          {placeholderText || t('qrCode:qrCodeWillShow')}
+        </p>
       </div>
     );
   }
@@ -41,34 +46,34 @@ const QrCodePreview = ({
   return (
     <div
       className={cn(
-        'flex flex-col justify-center items-center min-h-[200px] border border-input rounded-xl p-6 bg-muted/40',
+        'flex flex-col justify-center items-center border border-input rounded-xl p-4 bg-muted/40',
         className,
       )}
       {...props}
     >
       <div className="flex flex-col items-center w-full max-w-xs">
         {/*
-          2. 二维码容器适配：
+          二维码容器适配：
           在暗黑模式下，纯黑白的二维码如果直接暴露在暗色背景下，会导致手机摄像头极难识别。
-          通过裹一层 bg-white 和 p-3，确保黑白对比度绝对安全，同时加入 shadow 增强卡片感。
+          通过裹一层 bg-white 和 p-2，确保黑白对比度绝对安全，同时加入 shadow 增强卡片感。
         */}
-        <div className="p-3 bg-white rounded-lg shadow-sm border border-border/40">
+        <div className="p-2 bg-white rounded-lg shadow-sm border border-border/40">
           <img
             src={qrCodeDataUrl}
             alt="QR Code Preview"
-            className="w-56 h-56 max-w-full object-contain block animate-in fade-in duration-300"
+            className="w-48 h-48 max-w-full object-contain block animate-in fade-in duration-300"
           />
         </div>
 
-        <div className="flex w-full gap-2 mt-5">
-          <Button variant="outline" size="sm" onClick={onDownload} className="flex-1">
-            <Download className="w-4 h-4 text-muted-foreground" />
-            <span className="truncate">{t('qrCode:downloadButton')}</span>
+        <div className="flex w-full gap-2 mt-3">
+          <Button variant="outline" size="sm" onClick={onDownload} className="flex-1 h-8">
+            <Download className="w-3.5 h-3.5 text-muted-foreground" />
+            <span className="truncate text-xs">{t('qrCode:downloadButton')}</span>
           </Button>
 
-          <Button variant="default" size="sm" onClick={onCopy} className="flex-1">
-            <Copy className="w-4 h-4" />
-            <span className="truncate">{t('qrCode:copyQrButton')}</span>
+          <Button variant="default" size="sm" onClick={onCopy} className="flex-1 h-8">
+            <Copy className="w-3.5 h-3.5" />
+            <span className="truncate text-xs">{t('qrCode:copyQrButton')}</span>
           </Button>
         </div>
       </div>

src/components/RouterContainer.tsx

@@ -1,21 +1,20 @@
 import { FEATURES, getEntryPointType } from '@/config/features';
 import { useRouter } from '@/providers/RouterProvider';
-import { Suspense, useMemo } from 'react';
+import { Suspense } from 'react';
 import { useI18n } from '@/utils/chromeI18n';
 import PageErrorBoundary from '@/components/PageErrorBoundary';
 import PageSkeleton from '@/components/PageSkeleton';
 import { cn } from '@/lib/utils';
 import { AlertTriangle } from 'lucide-react';
 
+const entryPointType = getEntryPointType();
+
 export default function RouterContainer() {
   const { currentPage, isLoaded } = useRouter();
   const { t } = useI18n('common');
 
-  const animationClass = useMemo(() => {
-    return currentPage === 'dashboard' ? 'page-transition-dashboard' : 'page-transition-enter';
-  }, [currentPage]);
-
-  const entryPointType = getEntryPointType();
+  const animationClass =
+    currentPage === 'dashboard' ? 'page-transition-dashboard' : 'page-transition-enter';
 
   if (!isLoaded) {
     return <PageSkeleton variant={currentPage === 'dashboard' ? 'dashboard' : 'tool'} />;

src/components/__tests__/CopyButton.test.tsx

@@ -0,0 +1,194 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { act, render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+// unmock the globally-mocked component so we test the real implementation
+vi.unmock('@/components/CopyButton');
+
+vi.mock('@/utils/clipboard', () => ({
+  copyTextToClipboard: vi.fn(),
+}));
+
+vi.mock('sonner', () => ({
+  toast: {
+    success: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+import { CopyButton } from '@/components/CopyButton';
+import { copyTextToClipboard } from '@/utils/clipboard';
+import { toast } from 'sonner';
+
+const mockedCopy = vi.mocked(copyTextToClipboard);
+const mockedToast = vi.mocked(toast);
+
+describe('CopyButton', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('复制成功时调用 copyTextToClipboard 并传入正确 text', async () => {
+    mockedCopy.mockResolvedValue(true);
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+
+    render(<CopyButton text="hello world" />);
+
+    await user.click(screen.getByRole('button'));
+
+    expect(mockedCopy).toHaveBeenCalledWith('hello world');
+    expect(mockedToast.success).toHaveBeenCalled();
+  });
+
+  it('复制成功后图标切换为 Check，1.5 秒后恢复', async () => {
+    mockedCopy.mockResolvedValue(true);
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+
+    render(<CopyButton text="test" />);
+
+    // 点击后复制成功，按钮获得 emerald 样式（说明切到了 Check 状态）
+    await user.click(screen.getByRole('button'));
+
+    await waitFor(() => {
+      expect(screen.getByRole('button').className).toContain('text-emerald');
+    });
+
+    // 1.5 秒后样式恢复
+    act(() => {
+      vi.advanceTimersByTime(1500);
+    });
+
+    await waitFor(() => {
+      expect(screen.getByRole('button').className).not.toContain('text-emerald');
+    });
+  });
+
+  it('复制空文本时弹出 error toast', async () => {
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+
+    render(<CopyButton text="" />);
+
+    await user.click(screen.getByRole('button'));
+
+    expect(mockedCopy).not.toHaveBeenCalled();
+    expect(mockedToast.error).toHaveBeenCalled();
+  });
+
+  it('复制失败时弹出 error toast', async () => {
+    mockedCopy.mockResolvedValue(false);
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+
+    render(<CopyButton text="something" />);
+
+    await user.click(screen.getByRole('button'));
+
+    expect(mockedCopy).toHaveBeenCalledWith('something');
+    expect(mockedToast.error).toHaveBeenCalled();
+  });
+
+  // ==================== 新增测试 ====================
+
+  it('初始渲染时显示 Copy 图标且无 emerald 样式', () => {
+    render(<CopyButton text="initial" />);
+
+    const button = screen.getByRole('button');
+    expect(button.className).not.toContain('text-emerald');
+    // 通过 aria-label 确认按钮存在，图标由 lucide 渲染为 svg
+    expect(button).toHaveAttribute('aria-label');
+  });
+
+  it('自定义 tooltip 会覆盖默认 title 和 aria-label', () => {
+    render(<CopyButton text="tooltip-test" tooltip="自定义提示" />);
+
+    const button = screen.getByRole('button');
+    expect(button).toHaveAttribute('title', '自定义提示');
+    expect(button).toHaveAttribute('aria-label', '自定义提示');
+  });
+
+  it('className 被正确透传到按钮', () => {
+    render(<CopyButton text="class-test" className="my-custom-class" />);
+
+    const button = screen.getByRole('button');
+    expect(button.className).toContain('my-custom-class');
+  });
+
+  it('点击事件阻止冒泡', async () => {
+    mockedCopy.mockResolvedValue(true);
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+    const parentClick = vi.fn();
+
+    render(
+      <div onClick={parentClick}>
+        <CopyButton text="stop-propagation" />
+      </div>,
+    );
+
+    await user.click(screen.getByRole('button'));
+
+    expect(mockedCopy).toHaveBeenCalled();
+    expect(parentClick).not.toHaveBeenCalled();
+  });
+
+  it('组件卸载时清除定时器，不触发状态更新警告', async () => {
+    mockedCopy.mockResolvedValue(true);
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+
+    const { unmount } = render(<CopyButton text="unmount-test" />);
+
+    await user.click(screen.getByRole('button'));
+
+    // 在 1.5 秒超时到期前卸载组件
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
+
+    // 卸载不应抛出 "Can't perform a React state update on an unmounted component" 警告
+    expect(() => unmount()).not.toThrow();
+
+    // 前进剩余时间，确认没有异常
+    act(() => {
+      vi.advanceTimersByTime(2000);
+    });
+  });
+
+  it('快速连续点击不会创建多个重叠定时器', async () => {
+    mockedCopy.mockResolvedValue(true);
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+
+    render(<CopyButton text="rapid-click" />);
+
+    const button = screen.getByRole('button');
+
+    // 快速点击 3 次
+    await user.click(button);
+    await user.click(button);
+    await user.click(button);
+
+    // copyTextToClipboard 应该被调用 3 次（每次点击都执行）
+    expect(mockedCopy).toHaveBeenCalledTimes(3);
+
+    // 但 setTimeout 相关的 clearTimeout + setTimeout 组合应正常工作
+    //  advance 1.5 秒后，copied 状态应恢复为 false
+    act(() => {
+      vi.advanceTimersByTime(1500);
+    });
+
+    await waitFor(() => {
+      expect(button.className).not.toContain('text-emerald');
+    });
+  });
+
+  it('其他 button props 通过 ...props 透传', () => {
+    render(<CopyButton text="props-test" data-testid="copy-btn" disabled id="copy-button-id" />);
+
+    const button = screen.getByRole('button');
+    expect(button).toHaveAttribute('data-testid', 'copy-btn');
+    expect(button).toBeDisabled();
+    expect(button).toHaveAttribute('id', 'copy-button-id');
+  });
+});

src/components/__tests__/GlobalSnackbar.test.tsx

@@ -1,117 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { act, render, renderHook, screen } from '@testing-library/react';
-import React from 'react';
-import {
-  GlobalSnackbar,
-  type GlobalSnackbarProps,
-  SnackbarProvider,
-  useSnackbar,
-  useSnackbarState,
-} from '@/components/GlobalSnackbar';
-
-describe('GlobalSnackbar 组件系统', () => {
-  const mockOnClose = vi.fn();
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    vi.useRealTimers();
-  });
-
-  const defaultProps: GlobalSnackbarProps = {
-    message: '测试消息',
-    open: true,
-    onClose: mockOnClose,
-  };
-
-  describe('GlobalSnackbar UI 渲染', () => {
-    it('应渲染消息内容', () => {
-      render(<GlobalSnackbar {...defaultProps} />);
-      expect(screen.getByText('测试消息')).toBeInTheDocument();
-    });
-
-    it('当 showAlert 为 true 时应渲染带样式的提示', () => {
-      render(<GlobalSnackbar {...defaultProps} showAlert={true} />);
-      // 验证是否包含消息文本
-      const alertElement = screen.getByText('测试消息');
-      expect(alertElement).toBeInTheDocument();
-      // 验证父元素有正确的样式类
-      const parent = alertElement.parentElement;
-      expect(parent).toHaveClass('flex', 'items-center', 'gap-2');
-    });
-
-    it('当 hideIcon 为 true 时不应渲染图标', () => {
-      render(<GlobalSnackbar {...defaultProps} hideIcon={true} />);
-      // 图标使用 lucide-react 的 svg 元素
-      const icon = document.querySelector('svg');
-      expect(icon).not.toBeInTheDocument();
-    });
-
-    it('应根据 severity 应用不同的样式', () => {
-      render(<GlobalSnackbar {...defaultProps} severity="error" />);
-      const message = screen.getByText('测试消息');
-      const parent = message.parentElement;
-      expect(parent).toHaveClass('bg-red-500');
-    });
-  });
-
-  describe('useSnackbarState Hook 逻辑', () => {
-    it('应返回初始状态', () => {
-      const { result } = renderHook(() => useSnackbarState());
-      expect(result.current.snackbarProps.open).toBe(false);
-      expect(result.current.snackbarProps.message).toBe('');
-    });
-
-    it('showMessage 应更新状态', () => {
-      const { result } = renderHook(() => useSnackbarState());
-
-      act(() => {
-        result.current.showMessage('新消息');
-      });
-
-      expect(result.current.snackbarProps.open).toBe(true);
-      expect(result.current.snackbarProps.message).toBe('新消息');
-    });
-
-    it('closeMessage 应关闭消息', () => {
-      const { result } = renderHook(() => useSnackbarState());
-
-      act(() => {
-        result.current.showMessage('消息');
-      });
-      act(() => {
-        result.current.closeMessage();
-      });
-
-      expect(result.current.snackbarProps.open).toBe(false);
-    });
-  });
-
-  describe('useSnackbar Context Hook 优先级', () => {
-    it('优先级验证: Call Options > Hook Options > Provider Options', () => {
-      const wrapper = ({ children }: { children: React.ReactNode }) => (
-        <SnackbarProvider initialOptions={{ severity: 'info' }}>{children}</SnackbarProvider>
-      );
-
-      const { result } = renderHook(() => useSnackbar({ severity: 'warning' }), { wrapper });
-
-      // 1. 测试 Hook Options 覆盖 Provider Options
-      act(() => {
-        result.current.showMessage('消息 1');
-      });
-
-      expect(screen.getByText('消息 1')).toBeInTheDocument();
-
-      // 2. 测试 Call Options 覆盖 Hook Options
-      act(() => {
-        result.current.showMessage('消息 2', { severity: 'error' });
-      });
-
-      expect(screen.getByText('消息 2')).toBeInTheDocument();
-    });
-  });
-});

src/components/__tests__/ImageUploader.test.tsx

@@ -13,10 +13,11 @@ const mockRevokeObjectURL = vi.fn();
 Object.defineProperty(window.URL, 'createObjectURL', { value: mockCreateObjectURL });
 Object.defineProperty(window.URL, 'revokeObjectURL', { value: mockRevokeObjectURL });
 
-vi.mock('@/components/GlobalSnackbar', () => ({
-  useSnackbar: () => ({
-    showMessage: vi.fn(),
-  }),
+vi.mock('sonner', () => ({
+  toast: {
+    success: vi.fn(),
+    error: vi.fn(),
+  },
 }));
 
 describe('ImageUploader 组件', () => {

src/components/__tests__/RouterContainer.test.tsx

@@ -2,7 +2,6 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { render } from '@testing-library/react';
 import RouterContainer from '@/components/RouterContainer';
 import { RouterProvider } from '@/providers/RouterProvider';
-import { SnackbarProvider } from '@/components/GlobalSnackbar';
 import type { PageType } from '@/types/storage';
 import React from 'react';
 
@@ -29,11 +28,7 @@ describe('RouterContainer 组件', () => {
   });
 
   const renderWithProvider = (ui: React.ReactElement) => {
-    return render(
-      <SnackbarProvider>
-        <RouterProvider>{ui}</RouterProvider>
-      </SnackbarProvider>,
-    );
+    return render(<RouterProvider>{ui}</RouterProvider>);
   };
 
   describe('渲染测试', () => {
@@ -74,11 +69,7 @@ describe('RouterContainer 组件', () => {
       const { rerender } = renderWithProvider(<RouterContainer />);
 
       mockRouterValue.currentPage = 'timestamp';
-      rerender(
-        <SnackbarProvider>
-          <RouterProvider>{<RouterContainer />}</RouterProvider>
-        </SnackbarProvider>,
-      );
+      rerender(<RouterProvider>{<RouterContainer />}</RouterProvider>);
 
       const box = document.querySelector('.page-transition-enter');
       expect(box).toBeInTheDocument();

src/components/__tests__/StorageCleanerConfirm.test.tsx

@@ -94,7 +94,7 @@ describe('StorageCleanerConfirm 组件', () => {
       renderComponent({ options: partialOptions });
 
       expect(screen.getByText(/Local Storage/)).toBeInTheDocument();
-      expect(screen.getByText(/IndexedDB/)).toBeInTheDocument();
+      expect(screen.getByText(/站点存储/)).toBeInTheDocument();
       expect(screen.queryByText(/Session Storage/)).not.toBeInTheDocument();
       expect(screen.queryByText(/Cookies$/)).not.toBeInTheDocument();
     });

src/components/__tests__/ToolCard.test.tsx

@@ -1,118 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { act, fireEvent, render, screen } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-import ToolCard from '@/pages/Dashboard/ToolCard';
-import { Clock } from 'lucide-react';
-
-describe('ToolCard 组件', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('渲染测试', () => {
-    it('应渲染标题和描述', () => {
-      render(
-        <ToolCard
-          title="测试工具"
-          description="这是一个测试工具"
-          colorKey="primary"
-          icon={Clock}
-          onNavigate={() => {}}
-        />,
-      );
-
-      expect(screen.getByText('测试工具')).toBeInTheDocument();
-      expect(screen.getByText('这是一个测试工具')).toBeInTheDocument();
-    });
-
-    it('无描述时仅渲染标题', () => {
-      render(<ToolCard title="仅标题" colorKey="primary" icon={Clock} onNavigate={() => {}} />);
-
-      expect(screen.getByText('仅标题')).toBeInTheDocument();
-    });
-
-    it('应渲染图标', () => {
-      const { container } = render(
-        <ToolCard title="带图标" colorKey="primary" icon={Clock} onNavigate={() => {}} />,
-      );
-
-      const svgElement = container.querySelector('svg');
-      expect(svgElement).toBeInTheDocument();
-    });
-
-    it('提供快照内容时应渲染快照', () => {
-      render(
-        <ToolCard
-          title="带快照"
-          colorKey="primary"
-          icon={Clock}
-          onNavigate={() => {}}
-          snapshot={<div data-testid="snapshot">快照内容</div>}
-        />,
-      );
-
-      expect(screen.getByTestId('snapshot')).toBeInTheDocument();
-    });
-
-    it('未提供快照时不渲染快照区域', () => {
-      const { container } = render(
-        <ToolCard
-          title="无快照"
-          colorKey="primary"
-          icon={Clock}
-          onClick={() => {}}
-          onNavigate={function (): void {
-            throw new Error('Function not implemented.');
-          }}
-        />,
-      );
-
-      expect(container.querySelector('[data-testid="snapshot"]')).not.toBeInTheDocument();
-    });
-
-    it('应使用 CardActionArea 渲染，支持键盘聚焦', () => {
-      render(<ToolCard title="可聚焦" colorKey="primary" icon={Clock} onNavigate={() => {}} />);
-
-      const button = screen.getByRole('button', { name: /可聚焦/ });
-      expect(button).toBeInTheDocument();
-    });
-  });
-
-  describe('交互测试', () => {
-    it('点击时应调用 onClick', () => {
-      const handleClick = vi.fn();
-      render(<ToolCard title="可点击" colorKey="primary" icon={Clock} onNavigate={handleClick} />);
-
-      const button = screen.getByRole('button', { name: /可点击/ });
-      fireEvent.click(button);
-
-      expect(handleClick).toHaveBeenCalledTimes(1);
-    });
-
-    it('按 Enter 键时应调用 onClick', async () => {
-      const handleClick = vi.fn();
-      render(
-        <ToolCard title="键盘可触发" colorKey="primary" icon={Clock} onNavigate={handleClick} />,
-      );
-
-      const button = screen.getByRole('button', { name: /键盘可触发/ });
-      await act(async () => {
-        button.focus();
-        await userEvent.keyboard('{Enter}');
-      });
-
-      expect(handleClick).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('样式测试', () => {
-    it('应应用自定义颜色代码', () => {
-      const { container } = render(
-        <ToolCard title="自定义颜色" colorKey="warning" icon={Clock} onNavigate={() => {}} />,
-      );
-
-      const svgElement = container.querySelector('svg');
-      expect(svgElement).toBeInTheDocument();
-    });
-  });
-});

src/components/ui/dialog.tsx

@@ -26,10 +26,16 @@ const DialogOverlay = React.forwardRef<
 ));
 DialogOverlay.displayName = DialogPrimitive.Overlay.displayName;
 
+interface DialogContentProps extends React.ComponentPropsWithoutRef<
+  typeof DialogPrimitive.Content
+> {
+  showCloseButton?: boolean;
+}
+
 const DialogContent = React.forwardRef<
   React.ElementRef<typeof DialogPrimitive.Content>,
-  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>
->(({ className, children, ...props }, ref) => (
+  DialogContentProps
+>(({ className, children, showCloseButton = true, ...props }, ref) => (
   <DialogPortal>
     <DialogOverlay />
     <DialogPrimitive.Content
@@ -41,10 +47,12 @@ const DialogContent = React.forwardRef<
       {...props}
     >
       {children}
-      <DialogPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground">
-        <X className="h-4 w-4" />
-        <span className="sr-only">Close</span>
-      </DialogPrimitive.Close>
+      {showCloseButton && (
+        <DialogPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground">
+          <X className="h-4 w-4" />
+          <span className="sr-only">Close</span>
+        </DialogPrimitive.Close>
+      )}
     </DialogPrimitive.Content>
   </DialogPortal>
 ));

src/components/ui/sonner.tsx

@@ -0,0 +1,26 @@
+import { Toaster as Sonner } from 'sonner';
+import { useThemeMode } from '@/providers/ThemeModeProvider';
+
+type ToasterProps = React.ComponentProps<typeof Sonner>;
+
+export function Toaster(props: ToasterProps) {
+  const { resolvedMode } = useThemeMode();
+
+  return (
+    <Sonner
+      theme={resolvedMode}
+      className="toaster group"
+      position="bottom-center"
+      toastOptions={{
+        classNames: {
+          toast:
+            'group toast group-[.toaster]:bg-background group-[.toaster]:text-foreground group-[.toaster]:border-border group-[.toaster]:shadow-lg',
+          description: 'group-[.toast]:text-muted-foreground',
+          actionButton: 'group-[.toast]:bg-primary group-[.toast]:text-primary-foreground',
+          cancelButton: 'group-[.toast]:bg-muted group-[.toast]:text-muted-foreground',
+        },
+      }}
+      {...props}
+    />
+  );
+}

src/config/README.md

@@ -19,7 +19,7 @@
 - `defaultVisible`：默认是否可见
 - `components`：三种渲染模式的懒加载组件（`popup`、`sidepanel`、`tab`）
 
-## 已注册功能（11 个）
+## 已注册功能（10 个）
 
 | key                  | 图标              | 说明              |
 | -------------------- | ----------------- | ----------------- |
@@ -31,9 +31,8 @@
 | `jwt`                | Key               | JWT 解析工具      |
 | `jsonDiff`           | GitCompareArrows  | JSON 差异比较工具 |
 | `base64Converter`    | ArrowLeftRight    | Base64 转换器     |
-| `markdownToHtml`     | Code              | Markdown 转 HTML  |
-| `htmlToMarkdown`     | File              | HTML 转 Markdown  |
 | `rightClickRestorer` | MousePointerClick | 右键菜单恢复工具  |
+| `testDataGenerator`  | FileSpreadsheet   | 测试数据生成器    |
 
 ## 导出函数
 

src/config/__tests__/features.test.ts

@@ -9,8 +9,8 @@ import {
 
 describe('features', () => {
   describe('FEATURES', () => {
-    it('should have 9 features defined', () => {
-      expect(FEATURES).toHaveLength(9);
+    it('should have 10 features defined', () => {
+      expect(FEATURES).toHaveLength(10);
     });
 
     it('should have all required properties for each feature', () => {
@@ -95,7 +95,7 @@ describe('features', () => {
   describe('getAllFeatureKeys', () => {
     it('should return all feature keys', () => {
       const allKeys = getAllFeatureKeys();
-      expect(allKeys).toHaveLength(9);
+      expect(allKeys).toHaveLength(10);
       expect(allKeys).toContain('dashboard');
       expect(allKeys).toContain('timestamp');
       expect(allKeys).toContain('storageCleaner');
@@ -105,6 +105,7 @@ describe('features', () => {
       expect(allKeys).toContain('jsonDiff');
       expect(allKeys).toContain('base64Converter');
       expect(allKeys).toContain('rightClickRestorer');
+      expect(allKeys).toContain('testDataGenerator');
     });
   });
 
@@ -121,9 +122,9 @@ describe('features', () => {
       expect(pageOrder).toContain('qrCode');
     });
 
-    it('should have 8 items in page order', () => {
+    it('should have 9 items in page order', () => {
       const pageOrder = getDefaultPageOrder();
-      expect(pageOrder).toHaveLength(8);
+      expect(pageOrder).toHaveLength(9);
     });
   });
 });

src/config/features.tsx

@@ -10,6 +10,7 @@ import {
   GitCompareArrows,
   ArrowLeftRight,
   MousePointerClick,
+  FileSpreadsheet,
 } from 'lucide-react';
 
 export type PaletteColorKey = 'primary' | 'success' | 'warning' | 'error' | 'secondary' | 'info';
@@ -24,6 +25,7 @@ const JwtPage = lazy(() => import('@/pages/Jwt'));
 const JsonToolsPage = lazy(() => import('@/pages/JsonTools'));
 const Base64ConverterPage = lazy(() => import('@/pages/Base64Converter'));
 const RightClickRestorerPage = lazy(() => import('@/pages/RightClickRestorer'));
+const TestDataGeneratorPage = lazy(() => import('@/pages/TestDataGenerator'));
 
 export interface FeatureConfig {
   key: PageType;
@@ -155,6 +157,19 @@ export const FEATURES: FeatureConfig[] = [
       tab: RightClickRestorerPage,
     },
   },
+  {
+    key: 'testDataGenerator',
+    labelKey: 'testDataGenerator_title',
+    descriptionKey: 'testDataGenerator_description',
+    themeColorKey: 'warning',
+    icon: FileSpreadsheet,
+    defaultVisible: true,
+    components: {
+      popup: TestDataGeneratorPage,
+      sidepanel: TestDataGeneratorPage,
+      tab: TestDataGeneratorPage,
+    },
+  },
 ];
 
 export function getFeatureByKey(key: PageType): FeatureConfig | undefined {

src/entrypoints/background.ts

@@ -3,6 +3,7 @@ import { browser } from 'wxt/browser';
 import { MessageAction, onMessage, sendMessage } from '@/utils/messages';
 import { createAllContextMenus, parseContextMenuClick } from '@/utils/contextMenu';
 import { saveContextMenuData } from '@/utils/useContextMenuData';
+import { mainWorldInjectionScript } from '@/utils/rightClickInjection';
 
 export default defineBackground(() => {
   // 1. 扩展初次安装或更新时，注册右键上下文菜单
@@ -71,68 +72,7 @@ export default defineBackground(() => {
     try {
       await browser.scripting.executeScript({
         target: { tabId },
-        func: () => {
-          'use strict';
-          const w = window as unknown as Record<string, unknown>;
-          if (w.__testingToolsRightClickPatched) return;
-          w.__testingToolsRightClickPatched = true;
-
-          const PROTECTED = ['contextmenu', 'copy', 'paste', 'cut', 'selectstart'];
-
-          const _origPreventDefault = MouseEvent.prototype.preventDefault;
-          Object.defineProperty(MouseEvent.prototype, 'preventDefault', {
-            value: function (this: MouseEvent) {
-              const t = this.type;
-              if (PROTECTED.includes(t) || (t === 'mousedown' && this.button === 2)) {
-                return;
-              }
-              return _origPreventDefault.call(this);
-            },
-            writable: true,
-            configurable: true,
-          });
-
-          const _origStopPropagation = Event.prototype.stopPropagation;
-          Object.defineProperty(Event.prototype, 'stopPropagation', {
-            value: function (this: Event) {
-              if (PROTECTED.includes(this.type)) return;
-              return _origStopPropagation.call(this);
-            },
-            writable: true,
-            configurable: true,
-          });
-
-          const _origStopImmediatePropagation = Event.prototype.stopImmediatePropagation;
-          Object.defineProperty(Event.prototype, 'stopImmediatePropagation', {
-            value: function (this: Event) {
-              if (PROTECTED.includes(this.type)) return;
-              return _origStopImmediatePropagation.call(this);
-            },
-            writable: true,
-            configurable: true,
-          });
-
-          let _docOnContextMenu: unknown = null;
-          Object.defineProperty(document, 'oncontextmenu', {
-            get() {
-              return _docOnContextMenu;
-            },
-            set(fn: unknown) {
-              if (typeof fn === 'function') {
-                _docOnContextMenu = function (this: GlobalEventHandlers, e: MouseEvent) {
-                  const r = (fn as (this: GlobalEventHandlers, ev: MouseEvent) => unknown).call(
-                    this,
-                    e,
-                  );
-                  return r === false ? true : r;
-                };
-              } else {
-                _docOnContextMenu = fn;
-              }
-            },
-            configurable: true,
-          });
-        },
+        func: mainWorldInjectionScript,
         world: 'MAIN',
       });
 
@@ -143,41 +83,4 @@ export default defineBackground(() => {
       return { success: false, message: errorMsg };
     }
   });
-
-  onMessage(MessageAction.RELOAD_TAB, async (message) => {
-    const { tabId, delay = 0 } = message.data;
-
-    const executeReload = () => {
-      browser.tabs.reload(tabId).catch((err) => {
-        console.error('Failed to execute tab reload operation:', err);
-      });
-    };
-
-    if (delay <= 0) {
-      executeReload();
-      return { success: true };
-    }
-
-    const alarmName = `reload-tab-${tabId}-${Date.now()}`;
-
-    await browser.alarms.create(alarmName, { when: Date.now() + delay });
-
-    const cleanupTimeout = setTimeout(() => {
-      browser.alarms.onAlarm.removeListener(alarmListener);
-      browser.alarms.clear(alarmName).catch(() => {});
-    }, delay + 5000);
-
-    const alarmListener = (alarm: { name: string }) => {
-      if (alarm.name !== alarmName) return;
-
-      clearTimeout(cleanupTimeout);
-      executeReload();
-      browser.alarms.onAlarm.removeListener(alarmListener);
-      browser.alarms.clear(alarmName).catch(() => {});
-    };
-
-    browser.alarms.onAlarm.addListener(alarmListener);
-
-    return { success: true };
-  });
 });

src/entrypoints/content.ts

@@ -1,10 +1,10 @@
 import '../../.wxt/types/imports.d.ts';
-import { initMessageHandler } from './content/messageHandler';
+import { initContextMenuHandler } from './content/contextMenuHandler';
 
 export default defineContentScript({
   matches: ['<all_urls>'],
   runAt: 'document_end',
   main() {
-    initMessageHandler();
+    initContextMenuHandler();
   },
 });

src/entrypoints/content/contextMenuHandler.ts

@@ -1,17 +1,11 @@
 import type { ContextMenuClickedPayload } from '@/utils/messages';
 import { MessageAction, onMessage } from '@/utils/messages';
 import { getTextStats } from '@/utils/textStatistics';
+import { getMessage } from '@/utils/chromeI18n';
 import { hidePopover, showTextStatsResult, showTimestampResult } from './uiPopover';
 
-function getI18nText(key: string, fallback: string): string {
-  if (typeof chrome !== 'undefined' && chrome.i18n) {
-    return chrome.i18n.getMessage(key) || fallback;
-  }
-  return fallback;
-}
-
 function convertTimestamp(input: string): string {
-  const invalidText = getI18nText('invalidTimestamp', 'Invalid Timestamp');
+  const invalidText = getMessage('invalidTimestamp') || 'Invalid Timestamp';
   const num = Number(input.trim());
 
   if (isNaN(num)) {

src/entrypoints/content/messageHandler.ts

@@ -1,5 +0,0 @@
-import { initContextMenuHandler } from './contextMenuHandler';
-
-export function initMessageHandler(): void {
-  initContextMenuHandler();
-}

src/entrypoints/content/uiPopover.ts

@@ -161,7 +161,7 @@ function positionPopover(popover: HTMLElement, x: number, y: number): void {
 
 let hideTimeout: ReturnType<typeof setTimeout> | null = null;
 
-export function showPopover(
+function showPopover(
   x: number,
   y: number,
   contentHtml: string,

src/entrypoints/popup/App.tsx

@@ -2,27 +2,22 @@ import RouterProvider from '@/providers/RouterProvider';
 import TopBar from '@/components/TopBar';
 import RouterContainer from '@/components/RouterContainer';
 import ErrorBoundary from '@/components/ErrorBoundary';
-import { SnackbarProvider } from '@/components/GlobalSnackbar';
 import { getEntryPointType } from '@/config/features';
-import { useMemo } from 'react';
-
 export default function App() {
-  const entryType = useMemo(() => getEntryPointType(), []);
+  const entryType = getEntryPointType();
 
-  const routerConfig = useMemo(() => {
-    if (entryType === 'tab') {
-      return {
-        syncKey: 'app/tabRoute' as const,
-        visiblePagesKey: 'app/tabVisiblePages' as const,
-        pageOrderKey: 'app/tabPageOrder' as const,
-      };
-    }
-    return {
-      syncKey: 'app/popupRoute' as const,
-      visiblePagesKey: 'app/popupVisiblePages' as const,
-      pageOrderKey: 'app/popupPageOrder' as const,
-    };
-  }, [entryType]);
+  const routerConfig =
+    entryType === 'tab'
+      ? {
+          syncKey: 'app/tabRoute' as const,
+          visiblePagesKey: 'app/tabVisiblePages' as const,
+          pageOrderKey: 'app/tabPageOrder' as const,
+        }
+      : {
+          syncKey: 'app/popupRoute' as const,
+          visiblePagesKey: 'app/popupVisiblePages' as const,
+          pageOrderKey: 'app/popupPageOrder' as const,
+        };
 
   return (
     <RouterProvider
@@ -30,14 +25,12 @@ export default function App() {
       visiblePagesKey={routerConfig.visiblePagesKey}
       pageOrderKey={routerConfig.pageOrderKey}
     >
-      <SnackbarProvider initialOptions={{ autoHideDuration: 1500 }}>
-        <div className="app flex flex-col w-[400px] max-w-[400px] min-w-[400px] h-[600px] min-h-[600px] overflow-hidden bg-background sm:w-screen sm:max-w-none sm:min-w-0 sm:h-screen sm:min-h-0">
-          <TopBar />
-          <ErrorBoundary>
-            <RouterContainer />
-          </ErrorBoundary>
-        </div>
-      </SnackbarProvider>
+      <div className="app flex flex-col w-[400px] max-w-[400px] min-w-[400px] h-[600px] min-h-[600px] overflow-hidden bg-background sm:w-screen sm:max-w-none sm:min-w-0 sm:h-screen sm:min-h-0">
+        <TopBar />
+        <ErrorBoundary>
+          <RouterContainer />
+        </ErrorBoundary>
+      </div>
     </RouterProvider>
   );
 }

src/entrypoints/rightClickRestorer.content.ts

@@ -1,57 +1,7 @@
 import { MessageAction, onMessage, sendMessage } from '@/utils/messages';
 
-const BADGE_ID = 'testing-tools-right-click-restorer-badge';
-const BADGE_STYLE_ID = 'testing-tools-right-click-restorer-badge-style';
-
 let isRestored = false;
 
-function updateBadge(): void {
-  const badge = document.getElementById(BADGE_ID);
-  if (badge) {
-    badge.style.opacity = isRestored ? '1' : '0';
-  }
-}
-
-function createBadge(): void {
-  if (document.getElementById(BADGE_ID)) return;
-
-  if (!document.getElementById(BADGE_STYLE_ID)) {
-    const style = document.createElement('style');
-    style.id = BADGE_STYLE_ID;
-    style.textContent = `
-      #${BADGE_ID} {
-        position: fixed;
-        bottom: 16px;
-        right: 16px;
-        z-index: 2147483646;
-        padding: 6px 12px;
-        background: #2e7d32;
-        color: #ffffff;
-        border-radius: 20px;
-        font-size: 12px;
-        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-        box-shadow: 0 2px 8px rgba(0,0,0,0.2);
-        opacity: 0;
-        transition: opacity 0.2s ease-out;
-        pointer-events: none;
-        user-select: none;
-      }
-      @media (prefers-color-scheme: dark) {
-        #${BADGE_ID} {
-          background: #4caf50;
-          box-shadow: 0 2px 8px rgba(0,0,0,0.4);
-        }
-      }
-    `;
-    document.head.appendChild(style);
-  }
-
-  const badge = document.createElement('div');
-  badge.id = BADGE_ID;
-  badge.textContent = '\u53f3\u952e\u5df2\u89e3\u9501';
-  document.body.appendChild(badge);
-}
-
 /* ======================== Main World 注入 ======================== */
 
 async function injectMainWorldScript(): Promise<void> {
@@ -90,64 +40,6 @@ function installEventIntercepts(): void {
   );
 }
 
-/* ======================== 遮罩层穿透 ======================== */
-
-const MEDIA_TAGS = new Set(['IMG', 'VIDEO', 'CANVAS', 'SVG']);
-
-function initMousePenetration(): void {
-  window.addEventListener(
-    'mousedown',
-    (e) => {
-      if (!isRestored || e.button !== 2) return;
-
-      const elements = document.elementsFromPoint(e.clientX, e.clientY);
-      if (!elements.length) return;
-
-      let targetMedia: HTMLElement | null = null;
-      for (const el of elements) {
-        if (MEDIA_TAGS.has(el.tagName)) {
-          targetMedia = el as HTMLElement;
-          break;
-        }
-      }
-
-      if (!targetMedia) return;
-
-      const modified: Array<{ el: HTMLElement; original: string | null }> = [];
-      let foundMedia = false;
-
-      for (const el of elements) {
-        const htmlEl = el as HTMLElement;
-
-        if (el === targetMedia) {
-          foundMedia = true;
-          const original = htmlEl.style.pointerEvents || null;
-          htmlEl.style.setProperty('pointer-events', 'all', 'important');
-          modified.push({ el: htmlEl, original });
-          continue;
-        }
-
-        if (!foundMedia) {
-          const original = htmlEl.style.pointerEvents || null;
-          htmlEl.style.setProperty('pointer-events', 'none', 'important');
-          modified.push({ el: htmlEl, original });
-        }
-      }
-
-      setTimeout(() => {
-        for (const { el, original } of modified) {
-          if (original === null || original === '') {
-            el.style.removeProperty('pointer-events');
-          } else {
-            el.style.pointerEvents = original;
-          }
-        }
-      }, 300);
-    },
-    true,
-  );
-}
-
 /* ======================== 激活保护 ======================== */
 
 async function activateProtection(): Promise<void> {
@@ -159,10 +51,8 @@ async function activateProtection(): Promise<void> {
   if (isRestored) return;
 
   installEventIntercepts();
-  initMousePenetration();
 
   isRestored = true;
-  updateBadge();
 }
 
 /* ======================== 消息通信 ======================== */
@@ -184,11 +74,6 @@ export default defineContentScript({
   matches: ['<all_urls>'],
   runAt: 'document_start',
   main() {
-    if (document.readyState === 'loading') {
-      document.addEventListener('DOMContentLoaded', createBadge, { once: true });
-    } else {
-      createBadge();
-    }
     initMessaging();
   },
 });

src/entrypoints/sidepanel/App.tsx

@@ -3,7 +3,6 @@ import RouterProvider from '@/providers/RouterProvider';
 import TopBar from '@/components/TopBar';
 import RouterContainer from '@/components/RouterContainer';
 import ErrorBoundary from '@/components/ErrorBoundary';
-import { SnackbarProvider } from '@/components/GlobalSnackbar';
 import { MessageAction, sendMessage } from '@/utils/messages';
 
 export default function App() {
@@ -16,14 +15,12 @@ export default function App() {
 
   return (
     <RouterProvider defaultRoute="dashboard" syncKey="app/sidepanelRoute">
-      <SnackbarProvider initialOptions={{ autoHideDuration: 1500 }}>
-        <div className="app flex flex-col h-screen w-full overflow-hidden">
-          <TopBar />
-          <ErrorBoundary>
-            <RouterContainer />
-          </ErrorBoundary>
-        </div>
-      </SnackbarProvider>
+      <div className="app flex flex-col h-screen w-full overflow-hidden">
+        <TopBar />
+        <ErrorBoundary>
+          <RouterContainer />
+        </ErrorBoundary>
+      </div>
     </RouterProvider>
   );
 }

src/lib/README.md

@@ -4,9 +4,10 @@
 
 ## 文件说明
 
-| 文件       | 用途                                 |
-| ---------- | ------------------------------------ |
-| `utils.ts` | `cn()` 函数 — shadcn/ui 标准工具函数 |
+| 文件/目录     | 用途                                   |
+| ------------- | -------------------------------------- |
+| `utils.ts`    | `cn()` 函数 — shadcn/ui 标准工具函数   |
+| `generators/` | 测试数据生成器内置生成器库和分类注册表 |
 
 ## cn()
 
@@ -24,3 +25,32 @@ import { cn } from '@/lib/utils';
 ```
 
 所有需要动态合并 Tailwind 类名的场景都应使用 `cn()`，而非手动拼接字符串。
+
+## generators/
+
+测试数据生成器的核心生成器库，供 `src/workers/generator.worker.ts` 在后台线程中按字段配置生成数据。
+
+| 文件           | 用途                                           |
+| -------------- | ---------------------------------------------- |
+| `index.ts`     | 聚合所有生成器，导出分类、查找和搜索函数       |
+| `personal.ts`  | 个人信息生成器（姓名、邮箱、手机号、身份证等） |
+| `business.ts`  | 业务数据生成器（订单号、价格、日期、状态等）   |
+| `technical.ts` | 技术数据生成器（UUID、IPv4、URL）              |
+| `basic.ts`     | 基础类型生成器（整数、浮点数、布尔值、字符串） |
+| `types.ts`     | 生成器库内部类型与通用选项                     |
+
+使用示例：
+
+```typescript
+import { getGeneratorById, searchGenerators } from '@/lib/generators';
+
+const generator = getGeneratorById('chineseName');
+const value = generator?.generate({});
+const matched = searchGenerators('uuid');
+```
+
+约束：
+
+- 新增生成器必须实现 `GeneratorDefinition`，并加入所属分类文件的导出列表。
+- 需要唯一值或大批量稳定输出时，优先实现 `generateAtIndex(params, index)`。
+- 新增分类时同步更新 `generatorCategories`，并确保 `GeneratorSelector` 能展示该分类。

src/lib/generators/basic.ts

@@ -0,0 +1,227 @@
+/**
+ * 基础类型生成器
+ * 包含：随机整数、随机浮点数、随机字符串、从列表选择
+ */
+
+import type { GeneratorDefinition } from '@/types/testDataGenerator';
+
+/**
+ * 生成随机整数
+ */
+function randomInt(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/**
+ * 从数组中随机选择
+ */
+function randomPick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+/**
+ * 随机整数生成器
+ */
+export const randomIntGenerator: GeneratorDefinition = {
+  id: 'randomInt',
+  name: '随机整数',
+  description: '生成指定范围内的随机整数',
+  categoryId: 'basic',
+  params: [
+    {
+      key: 'min',
+      label: '最小值',
+      type: 'number',
+      defaultValue: 0,
+      description: '整数最小值',
+    },
+    {
+      key: 'max',
+      label: '最大值',
+      type: 'number',
+      defaultValue: 100,
+      description: '整数最大值',
+    },
+  ],
+  generate: (params) => {
+    const min = (params.min as number) || 0;
+    const max = (params.max as number) || 100;
+    return String(randomInt(min, max));
+  },
+  generateAtIndex: (params, index) => {
+    const min = (params.min as number) || 0;
+    const max = (params.max as number) || 100;
+    const range = max - min + 1;
+    return String(min + (index % range));
+  },
+};
+
+/**
+ * 随机浮点数生成器
+ */
+export const randomFloat: GeneratorDefinition = {
+  id: 'randomFloat',
+  name: '随机浮点数',
+  description: '生成指定范围内的随机浮点数',
+  categoryId: 'basic',
+  params: [
+    {
+      key: 'min',
+      label: '最小值',
+      type: 'number',
+      defaultValue: 0,
+      description: '浮点数最小值',
+    },
+    {
+      key: 'max',
+      label: '最大值',
+      type: 'number',
+      defaultValue: 100,
+      description: '浮点数最大值',
+    },
+    {
+      key: 'decimals',
+      label: '小数位数',
+      type: 'number',
+      defaultValue: 2,
+      min: 0,
+      max: 10,
+      description: '小数位数',
+    },
+  ],
+  generate: (params) => {
+    const min = (params.min as number) || 0;
+    const max = (params.max as number) || 100;
+    const decimals = (params.decimals as number) ?? 2;
+    const value = min + Math.random() * (max - min);
+    return value.toFixed(decimals);
+  },
+};
+
+/**
+ * 随机字符串生成器
+ */
+export const randomString: GeneratorDefinition = {
+  id: 'randomString',
+  name: '随机字符串',
+  description: '生成指定长度的随机字符串',
+  categoryId: 'basic',
+  params: [
+    {
+      key: 'length',
+      label: '字符串长度',
+      type: 'number',
+      defaultValue: 10,
+      min: 1,
+      max: 100,
+      description: '字符串长度',
+    },
+    {
+      key: 'charset',
+      label: '字符集',
+      type: 'select',
+      defaultValue: 'alphanumeric',
+      description: '使用的字符集',
+      options: [
+        { label: '字母数字', value: 'alphanumeric' },
+        { label: '仅字母', value: 'alpha' },
+        { label: '仅数字', value: 'numeric' },
+        { label: '小写字母', value: 'lowercase' },
+        { label: '大写字母', value: 'uppercase' },
+        { label: '十六进制', value: 'hex' },
+        { label: 'Base64', value: 'base64' },
+      ],
+    },
+  ],
+  generate: (params) => {
+    const length = (params.length as number) || 10;
+    const charset = (params.charset as string) || 'alphanumeric';
+
+    const charsets: Record<string, string> = {
+      alphanumeric: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
+      alpha: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+      numeric: '0123456789',
+      lowercase: 'abcdefghijklmnopqrstuvwxyz',
+      uppercase: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+      hex: '0123456789abcdef',
+      base64: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+    };
+
+    const chars = charsets[charset] || charsets.alphanumeric;
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  },
+  generateAtIndex: (params, index) => {
+    const length = (params.length as number) || 10;
+    const charset = (params.charset as string) || 'alphanumeric';
+
+    const charsets: Record<string, string> = {
+      alphanumeric: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
+      alpha: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+      numeric: '0123456789',
+      lowercase: 'abcdefghijklmnopqrstuvwxyz',
+      uppercase: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+      hex: '0123456789abcdef',
+      base64: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+    };
+
+    const chars = charsets[charset] || charsets.alphanumeric;
+    const base = String(index).padStart(length, '0');
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      const charIndex = parseInt(base[i]) || 0;
+      result += chars[charIndex % chars.length];
+    }
+    return result;
+  },
+};
+
+/**
+ * 从列表选择生成器
+ */
+export const fromList: GeneratorDefinition = {
+  id: 'fromList',
+  name: '从列表选择',
+  description: '从自定义列表中随机选择',
+  categoryId: 'basic',
+  params: [
+    {
+      key: 'values',
+      label: '列表值',
+      type: 'string',
+      defaultValue: '',
+      description: '列表值，用逗号分隔',
+      placeholder: '值1,值2,值3',
+    },
+    {
+      key: 'allowDuplicate',
+      label: '允许重复',
+      type: 'boolean',
+      defaultValue: true,
+      description: '是否允许重复选择',
+    },
+  ],
+  generate: (params) => {
+    const valuesStr = (params.values as string) || '';
+    const values = valuesStr
+      .split(',')
+      .map((v) => v.trim())
+      .filter((v) => v);
+
+    if (values.length === 0) {
+      return '（请配置列表值）';
+    }
+
+    return randomPick(values);
+  },
+};
+
+export const basicGenerators: GeneratorDefinition[] = [
+  randomIntGenerator,
+  randomFloat,
+  randomString,
+  fromList,
+];

src/lib/generators/business.ts

@@ -0,0 +1,561 @@
+/**
+ * 业务数据生成器
+ * 包含：订单号、价格、日期、状态、数量、评分、折扣、库存
+ */
+
+import type { GeneratorDefinition } from '@/types/testDataGenerator';
+
+/**
+ * 生成随机整数
+ */
+function randomInt(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/**
+ * 从数组中随机选择
+ */
+function randomPick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+/**
+ * 格式化日期
+ */
+function formatDate(date: Date, format: string): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
+
+  return format
+    .replace('YYYY', String(year))
+    .replace('MM', month)
+    .replace('DD', day)
+    .replace('HH', hours)
+    .replace('mm', minutes)
+    .replace('ss', seconds);
+}
+
+/**
+ * 订单号生成器
+ */
+export const orderId: GeneratorDefinition = {
+  id: 'orderId',
+  name: '订单号',
+  description: '生成随机订单号',
+  categoryId: 'business',
+  params: [
+    {
+      key: 'prefix',
+      label: '前缀',
+      type: 'string',
+      defaultValue: 'ORD',
+      description: '订单号前缀',
+      placeholder: '请输入前缀',
+    },
+    {
+      key: 'length',
+      label: '数字长度',
+      type: 'number',
+      defaultValue: 10,
+      min: 6,
+      max: 20,
+      description: '订单号数字部分长度',
+    },
+  ],
+  generate: (params) => {
+    const prefix = (params.prefix as string) || 'ORD';
+    const length = (params.length as number) || 10;
+    const maxNum = Math.pow(10, length) - 1;
+    const num = String(randomInt(0, maxNum)).padStart(length, '0');
+    return `${prefix}${num}`;
+  },
+  generateAtIndex: (params, index) => {
+    const prefix = (params.prefix as string) || 'ORD';
+    const length = (params.length as number) || 10;
+    const num = String(index + 1).padStart(length, '0');
+    return `${prefix}${num}`;
+  },
+};
+
+/**
+ * 价格生成器
+ */
+export const price: GeneratorDefinition = {
+  id: 'price',
+  name: '价格',
+  description: '生成随机价格',
+  categoryId: 'business',
+  params: [
+    {
+      key: 'min',
+      label: '最低价格',
+      type: 'number',
+      defaultValue: 1,
+      min: 0,
+      description: '价格最小值',
+    },
+    {
+      key: 'max',
+      label: '最高价格',
+      type: 'number',
+      defaultValue: 1000,
+      min: 0,
+      description: '价格最大值',
+    },
+    {
+      key: 'decimals',
+      label: '小数位数',
+      type: 'number',
+      defaultValue: 2,
+      min: 0,
+      max: 4,
+      description: '价格小数位数',
+    },
+    {
+      key: 'strategy',
+      label: '生成策略',
+      type: 'select',
+      defaultValue: 'random',
+      description: '价格生成策略',
+      options: [
+        { label: '随机', value: 'random' },
+        { label: '心理定价', value: 'psychological' },
+        { label: '真实分布', value: 'realistic' },
+      ],
+    },
+    {
+      key: 'currency',
+      label: '货币符号',
+      type: 'string',
+      defaultValue: '¥',
+      description: '货币符号',
+    },
+  ],
+  generate: (params) => {
+    const min = (params.min as number) || 1;
+    const max = (params.max as number) || 1000;
+    const decimals = (params.decimals as number) ?? 2;
+    const strategy = (params.strategy as string) || 'random';
+    const currency = (params.currency as string) || '¥';
+
+    let value: number;
+    if (strategy === 'psychological') {
+      value = generatePsychologicalPrice(min, max);
+    } else if (strategy === 'realistic') {
+      value = generateRealisticPrice(min, max);
+    } else {
+      value = min + Math.random() * (max - min);
+    }
+
+    return `${currency}${value.toFixed(decimals)}`;
+  },
+};
+
+/**
+ * 生成心理定价（如 9.99, 19.9, 99）
+ */
+function generatePsychologicalPrice(min: number, max: number): number {
+  const patterns = [
+    () => {
+      const base = randomInt(Math.ceil(min), Math.floor(max / 10));
+      return base * 10 - 0.01;
+    },
+    () => {
+      const base = randomInt(Math.ceil(min / 10), Math.floor(max / 10));
+      return base * 10 - 1;
+    },
+    () => {
+      const base = randomInt(Math.ceil(min / 100), Math.floor(max / 100));
+      return base * 100 - 1;
+    },
+  ];
+
+  let price = randomPick(patterns)();
+  if (price < min) price = min;
+  if (price > max) price = max;
+  return price;
+}
+
+/**
+ * 生成真实分布价格（对数正态分布）
+ */
+function generateRealisticPrice(min: number, max: number): number {
+  const mean = (Math.log(min) + Math.log(max)) / 2;
+  const stdDev = (Math.log(max) - Math.log(min)) / 4;
+  let u = 0,
+    v = 0;
+  while (u === 0) u = Math.random();
+  while (v === 0) v = Math.random();
+  const num = Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+  const value = Math.exp(mean + num * stdDev);
+  return Math.max(min, Math.min(max, value));
+}
+
+/**
+ * 日期生成器
+ */
+export const date: GeneratorDefinition = {
+  id: 'date',
+  name: '日期',
+  description: '生成随机日期',
+  categoryId: 'business',
+  params: [
+    {
+      key: 'startDate',
+      label: '开始日期',
+      type: 'string',
+      defaultValue: '2020-01-01',
+      description: '日期范围开始',
+      placeholder: 'YYYY-MM-DD',
+    },
+    {
+      key: 'endDate',
+      label: '结束日期',
+      type: 'string',
+      defaultValue: '2025-12-31',
+      description: '日期范围结束',
+      placeholder: 'YYYY-MM-DD',
+    },
+    {
+      key: 'format',
+      label: '日期格式',
+      type: 'select',
+      defaultValue: 'YYYY-MM-DD',
+      description: '输出格式',
+      options: [
+        { label: 'YYYY-MM-DD', value: 'YYYY-MM-DD' },
+        { label: 'YYYY/MM/DD', value: 'YYYY/MM/DD' },
+        { label: 'YYYY-MM-DD HH:mm:ss', value: 'YYYY-MM-DD HH:mm:ss' },
+        { label: 'YYYY/MM/DD HH:mm:ss', value: 'YYYY/MM/DD HH:mm:ss' },
+      ],
+    },
+  ],
+  generate: (params) => {
+    const startStr = (params.startDate as string) || '2020-01-01';
+    const endStr = (params.endDate as string) || '2025-12-31';
+    const format = (params.format as string) || 'YYYY-MM-DD';
+
+    const start = new Date(startStr).getTime();
+    const end = new Date(endStr).getTime();
+    const randomTime = start + Math.random() * (end - start);
+    const date = new Date(randomTime);
+
+    return formatDate(date, format);
+  },
+};
+
+/**
+ * 状态生成器
+ */
+export const status: GeneratorDefinition = {
+  id: 'status',
+  name: '状态',
+  description: '生成随机状态',
+  categoryId: 'business',
+  params: [
+    {
+      key: 'type',
+      label: '状态类型',
+      type: 'select',
+      defaultValue: 'order',
+      description: '选择状态类型',
+      options: [
+        { label: '订单状态', value: 'order' },
+        { label: '用户状态', value: 'user' },
+        { label: '审核状态', value: 'review' },
+        { label: '支付状态', value: 'payment' },
+        { label: '自定义', value: 'custom' },
+      ],
+    },
+    {
+      key: 'customValues',
+      label: '自定义值',
+      type: 'string',
+      defaultValue: '',
+      description: '自定义状态值，用逗号分隔',
+      placeholder: '状态1,状态2,状态3',
+    },
+  ],
+  generate: (params) => {
+    const type = (params.type as string) || 'order';
+
+    const statusMap: Record<string, string[]> = {
+      order: ['待付款', '待发货', '已发货', '已完成', '已取消', '已退款'],
+      user: ['活跃', '未激活', '已禁用', '已注销'],
+      review: ['待审核', '审核中', '已通过', '已拒绝'],
+      payment: ['待支付', '支付中', '支付成功', '支付失败', '已退款'],
+    };
+
+    if (type === 'custom') {
+      const customValues = (params.customValues as string) || '';
+      const values = customValues.split(',').filter((v) => v.trim());
+      if (values.length > 0) {
+        return randomPick(values);
+      }
+      return '未知状态';
+    }
+
+    return randomPick(statusMap[type] || statusMap.order);
+  },
+};
+
+/**
+ * 数量生成器
+ */
+export const quantity: GeneratorDefinition = {
+  id: 'quantity',
+  name: '数量',
+  description: '生成随机数量',
+  categoryId: 'business',
+  params: [
+    {
+      key: 'min',
+      label: '最小值',
+      type: 'number',
+      defaultValue: 1,
+      min: 0,
+      description: '数量最小值',
+    },
+    {
+      key: 'max',
+      label: '最大值',
+      type: 'number',
+      defaultValue: 100,
+      min: 0,
+      description: '数量最大值',
+    },
+    {
+      key: 'distribution',
+      label: '分布方式',
+      type: 'select',
+      defaultValue: 'uniform',
+      description: '数量分布方式',
+      options: [
+        { label: '均匀分布', value: 'uniform' },
+        { label: '泊松分布', value: 'poisson' },
+      ],
+    },
+  ],
+  generate: (params) => {
+    const min = (params.min as number) || 1;
+    const max = (params.max as number) || 100;
+    const distribution = (params.distribution as string) || 'uniform';
+
+    if (distribution === 'poisson') {
+      return String(poissonRandom(Math.floor((min + max) / 2)));
+    }
+    return String(randomInt(min, max));
+  },
+};
+
+/**
+ * 泊松分布随机数
+ */
+function poissonRandom(lambda: number): number {
+  const L = Math.exp(-lambda);
+  let k = 0;
+  let p = 1;
+  do {
+    k++;
+    p *= Math.random();
+  } while (p > L);
+  return k - 1;
+}
+
+/**
+ * 评分生成器
+ */
+export const rating: GeneratorDefinition = {
+  id: 'rating',
+  name: '评分',
+  description: '生成随机评分',
+  categoryId: 'business',
+  params: [
+    {
+      key: 'min',
+      label: '最低分',
+      type: 'number',
+      defaultValue: 1,
+      min: 0,
+      max: 10,
+      description: '评分最小值',
+    },
+    {
+      key: 'max',
+      label: '最高分',
+      type: 'number',
+      defaultValue: 5,
+      min: 0,
+      max: 10,
+      description: '评分最大值',
+    },
+    {
+      key: 'decimals',
+      label: '小数位数',
+      type: 'number',
+      defaultValue: 1,
+      min: 0,
+      max: 2,
+      description: '评分小数位数',
+    },
+    {
+      key: 'skewed',
+      label: '偏向高分',
+      type: 'boolean',
+      defaultValue: true,
+      description: '是否偏向高分（模拟真实评分分布）',
+    },
+  ],
+  generate: (params) => {
+    const min = (params.min as number) || 1;
+    const max = (params.max as number) || 5;
+    const decimals = (params.decimals as number) ?? 1;
+    const skewed = params.skewed !== false;
+
+    if (skewed) {
+      return skewedRandom(min, max).toFixed(decimals);
+    }
+    return (min + Math.random() * (max - min)).toFixed(decimals);
+  },
+};
+
+/**
+ * 偏向高分的随机数（模拟真实评分分布）
+ */
+function skewedRandom(min: number, max: number): number {
+  // 使用 Beta 分布模拟评分偏向
+  const alpha = 3;
+  const beta = 1;
+  let u = 0,
+    v = 0;
+  while (u === 0) u = Math.random();
+  while (v === 0) v = Math.random();
+  const x = Math.pow(u, 1 / alpha) / Math.pow(u, 1 / alpha) + Math.pow(v, 1 / beta);
+  return min + x * (max - min);
+}
+
+/**
+ * 折扣生成器
+ */
+export const discount: GeneratorDefinition = {
+  id: 'discount',
+  name: '折扣',
+  description: '生成随机折扣',
+  categoryId: 'business',
+  params: [
+    {
+      key: 'min',
+      label: '最低折扣',
+      type: 'number',
+      defaultValue: 1,
+      min: 0,
+      max: 100,
+      description: '折扣最小值（百分比）',
+    },
+    {
+      key: 'max',
+      label: '最高折扣',
+      type: 'number',
+      defaultValue: 50,
+      min: 0,
+      max: 100,
+      description: '折扣最大值（百分比）',
+    },
+    {
+      key: 'strategy',
+      label: '生成策略',
+      type: 'select',
+      defaultValue: 'random',
+      description: '折扣生成策略',
+      options: [
+        { label: '随机', value: 'random' },
+        { label: '心理定价', value: 'psychological' },
+      ],
+    },
+  ],
+  generate: (params) => {
+    const min = (params.min as number) || 1;
+    const max = (params.max as number) || 50;
+    const strategy = (params.strategy as string) || 'random';
+
+    let discount: number;
+    if (strategy === 'psychological') {
+      discount = generatePsychologicalDiscount(min, max);
+    } else {
+      discount = randomInt(min, max);
+    }
+    return `${discount}%`;
+  },
+};
+
+/**
+ * 生成心理折扣（如 5%, 10%, 20%, 30%）
+ */
+function generatePsychologicalDiscount(min: number, max: number): number {
+  const psychologicalDiscounts = [5, 10, 15, 20, 25, 30, 40, 50, 60, 70, 80];
+  const validDiscounts = psychologicalDiscounts.filter((d) => d >= min && d <= max);
+  if (validDiscounts.length > 0) {
+    return randomPick(validDiscounts);
+  }
+  return randomInt(min, max);
+}
+
+/**
+ * 库存生成器
+ */
+export const stock: GeneratorDefinition = {
+  id: 'stock',
+  name: '库存',
+  description: '生成随机库存数量',
+  categoryId: 'business',
+  params: [
+    {
+      key: 'min',
+      label: '最小库存',
+      type: 'number',
+      defaultValue: 0,
+      min: 0,
+      description: '库存最小值',
+    },
+    {
+      key: 'max',
+      label: '最大库存',
+      type: 'number',
+      defaultValue: 1000,
+      min: 0,
+      description: '库存最大值',
+    },
+    {
+      key: 'allowZero',
+      label: '允许为零',
+      type: 'boolean',
+      defaultValue: true,
+      description: '是否允许库存为零',
+    },
+  ],
+  generate: (params) => {
+    const min = (params.min as number) || 0;
+    const max = (params.max as number) || 1000;
+    const allowZero = params.allowZero !== false;
+
+    if (allowZero) {
+      return String(randomInt(min, max));
+    }
+    return String(randomInt(Math.max(1, min), max));
+  },
+};
+
+export const businessGenerators: GeneratorDefinition[] = [
+  orderId,
+  price,
+  date,
+  status,
+  quantity,
+  rating,
+  discount,
+  stock,
+];

src/lib/generators/index.ts

@@ -0,0 +1,57 @@
+/**
+ * 生成器库索引
+ * 导出所有生成器和分类配置
+ */
+
+import type { GeneratorDefinition, GeneratorCategory } from '@/types/testDataGenerator';
+import { personalGenerators } from './personal';
+import { businessGenerators } from './business';
+import { technicalGenerators } from './technical';
+import { basicGenerators } from './basic';
+
+/**
+ * 生成器分类配置
+ */
+export const generatorCategories: GeneratorCategory[] = [
+  { id: 'personal', name: '个人信息', icon: 'User' },
+  { id: 'business', name: '业务数据', icon: 'Briefcase' },
+  { id: 'technical', name: '技术数据', icon: 'Code' },
+  { id: 'basic', name: '基础类型', icon: 'Hash' },
+];
+
+/**
+ * 所有生成器列表
+ */
+export const allGenerators: GeneratorDefinition[] = [
+  ...personalGenerators,
+  ...businessGenerators,
+  ...technicalGenerators,
+  ...basicGenerators,
+];
+
+/**
+ * 根据 ID 获取生成器
+ */
+export function getGeneratorById(id: string): GeneratorDefinition | undefined {
+  return allGenerators.find((g) => g.id === id);
+}
+
+/**
+ * 根据分类 ID 获取生成器列表
+ */
+export function getGeneratorsByCategory(categoryId: string): GeneratorDefinition[] {
+  return allGenerators.filter((g) => g.categoryId === categoryId);
+}
+
+/**
+ * 搜索生成器
+ */
+export function searchGenerators(query: string): GeneratorDefinition[] {
+  const lowerQuery = query.toLowerCase();
+  return allGenerators.filter(
+    (g) =>
+      g.name.toLowerCase().includes(lowerQuery) ||
+      g.description.toLowerCase().includes(lowerQuery) ||
+      g.id.toLowerCase().includes(lowerQuery),
+  );
+}

src/lib/generators/personal.ts

@@ -0,0 +1,465 @@
+/**
+ * 个人信息生成器
+ * 包含：中文姓名、邮箱、手机号、身份证号、中文地址、年龄
+ */
+
+import type { GeneratorDefinition } from '@/types/testDataGenerator';
+
+// 中文姓氏
+const SURNAMES = [
+  '王',
+  '李',
+  '张',
+  '刘',
+  '陈',
+  '杨',
+  '赵',
+  '黄',
+  '周',
+  '吴',
+  '徐',
+  '孙',
+  '胡',
+  '朱',
+  '高',
+  '林',
+  '何',
+  '郭',
+  '马',
+  '罗',
+  '梁',
+  '宋',
+  '郑',
+  '谢',
+  '韩',
+  '唐',
+  '冯',
+  '于',
+  '董',
+  '萧',
+  '程',
+  '曹',
+  '袁',
+  '邓',
+  '许',
+  '傅',
+  '沈',
+  '曾',
+  '彭',
+  '吕',
+  '苏',
+  '卢',
+  '蒋',
+  '蔡',
+  '贾',
+  '丁',
+  '魏',
+  '薛',
+  '叶',
+  '阎',
+];
+
+// 中文名字常用字
+const NAME_CHARS = [
+  '伟',
+  '芳',
+  '娜',
+  '秀英',
+  '敏',
+  '静',
+  '丽',
+  '强',
+  '磊',
+  '洋',
+  '艳',
+  '勇',
+  '军',
+  '杰',
+  '娟',
+  '涛',
+  '明',
+  '超',
+  '秀兰',
+  '霞',
+  '平',
+  '刚',
+  '桂英',
+  '文',
+  '华',
+  '飞',
+  '鑫',
+  '浩',
+  '凯',
+  '宁',
+  '建',
+  '峰',
+  '辉',
+  '成',
+  '宇',
+  '博',
+  '泽',
+  '思',
+  '睿',
+  '晨',
+  '阳',
+  '雪',
+  '冰',
+  '琳',
+  '瑶',
+  '婷',
+  '欣',
+  '悦',
+  '佳',
+  '慧',
+];
+
+// 邮箱域名
+const EMAIL_DOMAINS = ['qq.com', '163.com', '126.com', 'gmail.com', 'outlook.com', 'hotmail.com'];
+
+// 省份
+const PROVINCES = [
+  '北京市',
+  '天津市',
+  '上海市',
+  '重庆市',
+  '河北省',
+  '山西省',
+  '辽宁省',
+  '吉林省',
+  '黑龙江省',
+  '江苏省',
+  '浙江省',
+  '安徽省',
+  '福建省',
+  '江西省',
+  '山东省',
+  '河南省',
+  '湖北省',
+  '湖南省',
+  '广东省',
+  '海南省',
+  '四川省',
+  '贵州省',
+  '云南省',
+  '陕西省',
+  '甘肃省',
+  '青海省',
+  '台湾省',
+  '内蒙古自治区',
+  '广西壮族自治区',
+  '西藏自治区',
+  '宁夏回族自治区',
+  '新疆维吾尔自治区',
+];
+
+// 城市
+const CITIES: Record<string, string[]> = {
+  北京市: ['东城区', '西城区', '朝阳区', '海淀区'],
+  上海市: ['黄浦区', '徐汇区', '长宁区', '静安区'],
+  广东省: ['广州市', '深圳市', '东莞市', '佛山市'],
+  浙江省: ['杭州市', '宁波市', '温州市', '嘉兴市'],
+  江苏省: ['南京市', '苏州市', '无锡市', '常州市'],
+  四川省: ['成都市', '绵阳市', '德阳市', '宜宾市'],
+};
+
+/**
+ * 生成随机整数
+ */
+function randomInt(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/**
+ * 从数组中随机选择
+ */
+function randomPick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+/**
+ * 中文姓名生成器
+ */
+export const chineseName: GeneratorDefinition = {
+  id: 'chineseName',
+  name: '中文姓名',
+  description: '生成随机中文姓名',
+  categoryId: 'personal',
+  params: [],
+  generate: () => {
+    const surname = randomPick(SURNAMES);
+    const name = randomPick(NAME_CHARS);
+    return surname + name;
+  },
+};
+
+/**
+ * 邮箱生成器
+ */
+export const email: GeneratorDefinition = {
+  id: 'email',
+  name: '邮箱',
+  description: '生成随机邮箱地址',
+  categoryId: 'personal',
+  params: [
+    {
+      key: 'domain',
+      label: '邮箱域名',
+      type: 'select',
+      defaultValue: 'random',
+      description: '选择邮箱域名',
+      options: [
+        { label: '随机', value: 'random' },
+        ...EMAIL_DOMAINS.map((d) => ({ label: d, value: d })),
+      ],
+    },
+  ],
+  generate: (params) => {
+    const domain =
+      params.domain === 'random' ? randomPick(EMAIL_DOMAINS) : (params.domain as string);
+    const username = Math.random().toString(36).substring(2, 10);
+    return `${username}@${domain}`;
+  },
+};
+
+/**
+ * 手机号生成器
+ */
+export const chinesePhone: GeneratorDefinition = {
+  id: 'chinesePhone',
+  name: '手机号',
+  description: '生成随机中国手机号码',
+  categoryId: 'personal',
+  params: [
+    {
+      key: 'prefix',
+      label: '号段前缀',
+      type: 'select',
+      defaultValue: 'random',
+      description: '选择手机号前缀',
+      options: [
+        { label: '随机', value: 'random' },
+        { label: '138', value: '138' },
+        { label: '139', value: '139' },
+        { label: '158', value: '158' },
+        { label: '188', value: '188' },
+        { label: '177', value: '177' },
+      ],
+    },
+  ],
+  generate: (params) => {
+    const prefixes = ['138', '139', '158', '188', '177', '136', '159', '186', '135', '150'];
+    const prefix = params.prefix === 'random' ? randomPick(prefixes) : (params.prefix as string);
+    const suffix = String(randomInt(10000000, 99999999));
+    return prefix + suffix;
+  },
+};
+
+/**
+ * 身份证号生成器
+ */
+export const idCard: GeneratorDefinition = {
+  id: 'idCard',
+  name: '身份证号',
+  description: '生成随机身份证号码',
+  categoryId: 'personal',
+  params: [
+    {
+      key: 'region',
+      label: '地区',
+      type: 'select',
+      defaultValue: 'random',
+      description: '选择身份证前6位地区码',
+      options: [
+        { label: '随机', value: 'random' },
+        { label: '北京', value: '110101' },
+        { label: '上海', value: '310101' },
+        { label: '广州', value: '440103' },
+        { label: '深圳', value: '440305' },
+      ],
+    },
+  ],
+  generate: (params) => {
+    const regions = ['110101', '310101', '440103', '440305', '510104', '330102'];
+    const region = params.region === 'random' ? randomPick(regions) : (params.region as string);
+
+    // 出生日期 1960-2005年
+    const year = randomInt(1960, 2005);
+    const month = String(randomInt(1, 12)).padStart(2, '0');
+    const day = String(randomInt(1, 28)).padStart(2, '0');
+    const birthday = `${year}${month}${day}`;
+
+    // 顺序码
+    const sequence = String(randomInt(1, 999)).padStart(3, '0');
+
+    // 前17位
+    const prefix17 = region + birthday + sequence;
+
+    // 校验码
+    const weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
+    const checkCodes = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];
+    let sum = 0;
+    for (let i = 0; i < 17; i++) {
+      sum += parseInt(prefix17[i]) * weights[i];
+    }
+    const checkCode = checkCodes[sum % 11];
+
+    return prefix17 + checkCode;
+  },
+  generateAtIndex: (params, index) => {
+    const regions = ['110101', '310101', '440103', '440305', '510104', '330102'];
+    const region =
+      params.region === 'random' ? regions[index % regions.length] : (params.region as string);
+
+    const year = 1990;
+    const month = String(randomInt(1, 12)).padStart(2, '0');
+    const day = String(randomInt(1, 28)).padStart(2, '0');
+    const birthday = `${year}${month}${day}`;
+
+    const sequence = String(index + 1).padStart(3, '0');
+    const prefix17 = region + birthday + sequence;
+
+    const weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
+    const checkCodes = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];
+    let sum = 0;
+    for (let i = 0; i < 17; i++) {
+      sum += parseInt(prefix17[i]) * weights[i];
+    }
+    const checkCode = checkCodes[sum % 11];
+
+    return prefix17 + checkCode;
+  },
+};
+
+/**
+ * 中文地址生成器
+ */
+export const chineseAddress: GeneratorDefinition = {
+  id: 'chineseAddress',
+  name: '中文地址',
+  description: '生成随机中文地址',
+  categoryId: 'personal',
+  params: [
+    {
+      key: 'includeDetail',
+      label: '包含详细地址',
+      type: 'boolean',
+      defaultValue: true,
+      description: '是否包含街道门牌号',
+    },
+  ],
+  generate: (params) => {
+    const province = randomPick(PROVINCES);
+    const cities = CITIES[province] || ['市区'];
+    const city = randomPick(cities);
+    const district = `区${randomInt(1, 20)}号`;
+
+    if (params.includeDetail) {
+      const street = `路${randomInt(1, 200)}号`;
+      return `${province}${city}${district}${street}`;
+    }
+    return `${province}${city}${district}`;
+  },
+};
+
+/**
+ * 年龄生成器
+ */
+export const age: GeneratorDefinition = {
+  id: 'age',
+  name: '年龄',
+  description: '生成随机年龄',
+  categoryId: 'personal',
+  params: [
+    {
+      key: 'min',
+      label: '最小年龄',
+      type: 'number',
+      defaultValue: 18,
+      min: 0,
+      max: 150,
+      description: '年龄最小值',
+    },
+    {
+      key: 'max',
+      label: '最大年龄',
+      type: 'number',
+      defaultValue: 65,
+      min: 0,
+      max: 150,
+      description: '年龄最大值',
+    },
+    {
+      key: 'distribution',
+      label: '分布方式',
+      type: 'select',
+      defaultValue: 'uniform',
+      description: '年龄分布方式',
+      options: [
+        { label: '均匀分布', value: 'uniform' },
+        { label: '正态分布', value: 'normal' },
+        { label: '人口统计分布', value: 'demographic' },
+      ],
+    },
+  ],
+  generate: (params) => {
+    const min = (params.min as number) || 18;
+    const max = (params.max as number) || 65;
+    const distribution = (params.distribution as string) || 'uniform';
+
+    if (distribution === 'normal') {
+      return String(normalRandom(min, max));
+    } else if (distribution === 'demographic') {
+      return String(demographicRandom());
+    }
+    return String(randomInt(min, max));
+  },
+};
+
+/**
+ * 正态分布随机数
+ */
+function normalRandom(min: number, max: number): number {
+  const mean = (min + max) / 2;
+  const stdDev = (max - min) / 6;
+  let u = 0,
+    v = 0;
+  while (u === 0) u = Math.random();
+  while (v === 0) v = Math.random();
+  const num = Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+  const value = Math.round(mean + num * stdDev);
+  return Math.max(min, Math.min(max, value));
+}
+
+/**
+ * 人口统计分布随机数（模拟真实年龄分布）
+ */
+function demographicRandom(): number {
+  const ageGroups = [
+    { min: 0, max: 14, weight: 0.18 },
+    { min: 15, max: 24, weight: 0.12 },
+    { min: 25, max: 34, weight: 0.18 },
+    { min: 35, max: 44, weight: 0.17 },
+    { min: 45, max: 54, weight: 0.16 },
+    { min: 55, max: 64, weight: 0.12 },
+    { min: 65, max: 100, weight: 0.07 },
+  ];
+
+  const random = Math.random();
+  let cumulative = 0;
+  for (const group of ageGroups) {
+    cumulative += group.weight;
+    if (random <= cumulative) {
+      return randomInt(group.min, group.max);
+    }
+  }
+  return randomInt(25, 34);
+}
+
+export const personalGenerators: GeneratorDefinition[] = [
+  chineseName,
+  email,
+  chinesePhone,
+  idCard,
+  chineseAddress,
+  age,
+];

src/lib/generators/technical.ts

@@ -0,0 +1,268 @@
+/**
+ * 技术数据生成器
+ * 包含：UUID、IPv4、URL
+ */
+
+import type { GeneratorDefinition } from '@/types/testDataGenerator';
+
+/**
+ * 生成随机整数
+ */
+function randomInt(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/**
+ * 从数组中随机选择
+ */
+function randomPick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+/**
+ * UUID 生成器
+ */
+export const uuid: GeneratorDefinition = {
+  id: 'uuid',
+  name: 'UUID',
+  description: '生成随机 UUID',
+  categoryId: 'technical',
+  params: [
+    {
+      key: 'version',
+      label: 'UUID 版本',
+      type: 'select',
+      defaultValue: 'v4',
+      description: 'UUID 版本',
+      options: [
+        { label: 'v4 (随机)', value: 'v4' },
+        { label: 'v1 (时间戳)', value: 'v1' },
+      ],
+    },
+    {
+      key: 'uppercase',
+      label: '大写字母',
+      type: 'boolean',
+      defaultValue: false,
+      description: '是否使用大写字母',
+    },
+    {
+      key: 'noDashes',
+      label: '无连字符',
+      type: 'boolean',
+      defaultValue: false,
+      description: '是否省略连字符',
+    },
+  ],
+  generate: (params) => {
+    const version = (params.version as string) || 'v4';
+    const uppercase = params.uppercase === true;
+    const noDashes = params.noDashes === true;
+
+    let result: string;
+    if (version === 'v1') {
+      result = generateUUIDv1();
+    } else {
+      result = generateUUIDv4();
+    }
+
+    if (uppercase) {
+      result = result.toUpperCase();
+    }
+
+    if (noDashes) {
+      result = result.replace(/-/g, '');
+    }
+
+    return result;
+  },
+};
+
+/**
+ * 生成 UUID v4
+ */
+function generateUUIDv4(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+/**
+ * 生成 UUID v1（简化版本，模拟时间戳）
+ */
+function generateUUIDv1(): string {
+  const now = Date.now();
+  const timeLow = (now & 0xffffffff).toString(16).padStart(8, '0');
+  const timeMid = ((now >> 32) & 0xffff).toString(16).padStart(4, '0');
+  const timeHi = ((now >> 48) & 0x0fff) | 0x1000;
+  const clockSeq = randomInt(0, 0x3fff) | 0x8000;
+  const node = Array.from({ length: 6 }, () =>
+    randomInt(0, 255).toString(16).padStart(2, '0'),
+  ).join('');
+
+  return `${timeLow}-${timeMid}-${timeHi.toString(16)}-${clockSeq.toString(16)}-${node}`;
+}
+
+/**
+ * IPv4 生成器
+ */
+export const ipv4: GeneratorDefinition = {
+  id: 'ipv4',
+  name: 'IPv4',
+  description: '生成随机 IPv4 地址',
+  categoryId: 'technical',
+  params: [
+    {
+      key: 'type',
+      label: '地址类型',
+      type: 'select',
+      defaultValue: 'random',
+      description: 'IP 地址类型',
+      options: [
+        { label: '完全随机', value: 'random' },
+        { label: '内网地址', value: 'private' },
+        { label: '公网地址', value: 'public' },
+        { label: '环回地址', value: 'loopback' },
+      ],
+    },
+  ],
+  generate: (params) => {
+    const type = (params.type as string) || 'random';
+
+    if (type === 'private') {
+      return generatePrivateIPv4();
+    } else if (type === 'loopback') {
+      return '127.0.0.1';
+    } else if (type === 'public') {
+      return generatePublicIPv4();
+    }
+    return generateRandomIPv4();
+  },
+};
+
+/**
+ * 生成完全随机 IPv4
+ */
+function generateRandomIPv4(): string {
+  return Array.from({ length: 4 }, () => randomInt(0, 255)).join('.');
+}
+
+/**
+ * 生成内网 IPv4
+ */
+function generatePrivateIPv4(): string {
+  const ranges = [
+    { prefix: '10', second: () => randomInt(0, 255) },
+    { prefix: '172', second: () => randomInt(16, 31) },
+    { prefix: '192.168', second: () => randomInt(0, 255) },
+  ];
+  const range = randomPick(ranges);
+
+  if (range.prefix === '192.168') {
+    return `192.168.${range.second()}.${randomInt(1, 254)}`;
+  }
+  return `${range.prefix}.${range.second()}.${randomInt(1, 254)}.${randomInt(1, 254)}`;
+}
+
+/**
+ * 生成公网 IPv4
+ */
+function generatePublicIPv4(): string {
+  let first: number;
+  do {
+    first = randomInt(1, 255);
+  } while (first === 10 || first === 127 || first === 192 || first === 172);
+
+  return `${first}.${randomInt(0, 255)}.${randomInt(0, 255)}.${randomInt(1, 254)}`;
+}
+
+/**
+ * URL 生成器
+ */
+export const url: GeneratorDefinition = {
+  id: 'url',
+  name: 'URL',
+  description: '生成随机 URL',
+  categoryId: 'technical',
+  params: [
+    {
+      key: 'protocol',
+      label: '协议',
+      type: 'select',
+      defaultValue: 'https',
+      description: 'URL 协议',
+      options: [
+        { label: 'HTTPS', value: 'https' },
+        { label: 'HTTP', value: 'http' },
+        { label: '随机', value: 'random' },
+      ],
+    },
+    {
+      key: 'type',
+      label: 'URL 类型',
+      type: 'select',
+      defaultValue: 'website',
+      description: 'URL 类型',
+      options: [
+        { label: '网站', value: 'website' },
+        { label: 'API', value: 'api' },
+        { label: '图片', value: 'image' },
+        { label: '文件', value: 'file' },
+      ],
+    },
+    {
+      key: 'includePath',
+      label: '包含路径',
+      type: 'boolean',
+      defaultValue: true,
+      description: '是否包含路径',
+    },
+  ],
+  generate: (params) => {
+    const protocol = (params.protocol as string) || 'https';
+    const type = (params.type as string) || 'website';
+    const includePath = params.includePath !== false;
+
+    const actualProtocol = protocol === 'random' ? randomPick(['http', 'https']) : protocol;
+
+    const domains = [
+      'example.com',
+      'test.org',
+      'demo.net',
+      'sample.io',
+      'api.service.com',
+      'cdn.static.com',
+      'img.media.com',
+    ];
+    const domain = randomPick(domains);
+
+    let path = '';
+    if (includePath) {
+      if (type === 'api') {
+        path = `/api/v${randomInt(1, 3)}/${randomPick(['users', 'products', 'orders', 'items'])}`;
+      } else if (type === 'image') {
+        path = `/images/${randomPick(['avatar', 'banner', 'logo', 'photo'])}/${randomInt(1, 1000)}.jpg`;
+      } else if (type === 'file') {
+        path = `/files/${randomPick(['document', 'report', 'data'])}/${randomInt(1, 100)}.pdf`;
+      } else {
+        path = `/${randomPick(['about', 'contact', 'products', 'services', 'blog'])}`;
+      }
+    }
+
+    // 添加查询参数
+    let query = '';
+    if (Math.random() > 0.5) {
+      const params = new URLSearchParams();
+      params.set('id', String(randomInt(1, 10000)));
+      if (Math.random() > 0.5) params.set('page', String(randomInt(1, 100)));
+      if (Math.random() > 0.7) params.set('lang', randomPick(['zh', 'en', 'ja']));
+      query = `?${params.toString()}`;
+    }
+
+    return `${actualProtocol}://${domain}${path}${query}`;
+  },
+};
+
+export const technicalGenerators: GeneratorDefinition[] = [uuid, ipv4, url];

src/lib/generators/types.ts

@@ -0,0 +1,48 @@
+/**
+ * 生成器内部类型定义
+ * 与 testDataGenerator.ts 分离，用于生成器库内部
+ */
+
+import type { GeneratorDefinition, GeneratorCategory } from '@/types/testDataGenerator';
+
+export type { GeneratorDefinition, GeneratorCategory };
+
+/**
+ * 生成器注册表
+ */
+export interface GeneratorRegistry {
+  /** 分类列表 */
+  categories: GeneratorCategory[];
+  /** 生成器列表 */
+  generators: GeneratorDefinition[];
+}
+
+/**
+ * 随机数生成选项
+ */
+export interface RandomOptions {
+  /** 最小值 */
+  min?: number;
+  /** 最大值 */
+  max?: number;
+  /** 是否包含最小值 */
+  includeMin?: boolean;
+  /** 是否包含最大值 */
+  includeMax?: boolean;
+}
+
+/**
+ * 字符集选项
+ */
+export interface CharsetOptions {
+  /** 是否包含大写字母 */
+  uppercase?: boolean;
+  /** 是否包含小写字母 */
+  lowercase?: boolean;
+  /** 是否包含数字 */
+  digits?: boolean;
+  /** 是否包含特殊字符 */
+  special?: boolean;
+  /** 自定义字符集 */
+  custom?: string;
+}

src/pages/Base64Converter/Base64ConverterSection.tsx

@@ -1,7 +1,7 @@
 import { Image as ImageIcon, Trash2, Upload } from 'lucide-react';
 import TextInputArea from '@/components/TextInputArea';
 import { useI18n } from '@/utils/chromeI18n';
-import CopyButton from '@/components/CopyButton';
+import { CopyButton } from '@/components/CopyButton';
 import DecodeResultPaper from '@/components/DecodeResultPaper';
 import { Button } from '@/components/ui/button';
 import { downloadBlob, formatFileSize } from '@/utils/base64Converter';
@@ -57,7 +57,7 @@ export default function Base64ConverterSection({ mode }: Base64ConverterSectionP
   };
 
   return (
-    <div className="w-full flex flex-col space-y-4">
+    <div className="w-full flex flex-col space-y-4 px-2">
       <div className="flex h-11 items-center px-1.5 bg-secondary/40 rounded-xl border border-border/60 w-fit">
         <SwitchButtonGroup
           value={direction}

src/pages/Base64Converter/TextMode.tsx

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import TextInputArea from '@/components/TextInputArea';
 import { useI18n } from '@/utils/chromeI18n';
-import CopyButton from '@/components/CopyButton';
+import { CopyButton } from '@/components/CopyButton';
 import { base64ToText, textToBase64 } from '@/utils/base64Converter';
 import SwitchButtonGroup from '@/components/SwitchButtonGroup';
 import { useContextMenuData } from '@/utils/useContextMenuData';
@@ -88,7 +88,7 @@ export default function TextMode({ onSwitchToImageMode }: TextModeProps = {}) {
   };
 
   return (
-    <div className="w-full flex flex-col space-y-4">
+    <div className="w-full flex flex-col space-y-4 px-2">
       {/* 受控方向切流中枢 */}
       <div className="flex h-11 items-center px-1.5 bg-secondary/40 rounded-xl border border-border/60 w-fit">
         <SwitchButtonGroup

src/pages/Dashboard/ToolCard.tsx

@@ -1,107 +0,0 @@
-import type { ComponentType } from 'react';
-import React from 'react';
-import type { LucideProps } from 'lucide-react';
-import { ChevronRight } from 'lucide-react';
-import type { PaletteColorKey } from '@/config/features';
-import { cn } from '@/lib/utils';
-
-const PALETTE_COLORS: Record<PaletteColorKey, string> = {
-  primary: '13, 148, 136', // teal
-  success: '22, 163, 74', // green
-  warning: '217, 119, 6', // amber (存储清理的橙色轴)
-  error: '220, 38, 38', // red
-  secondary: '147, 51, 232',
-  info: '37, 99, 235', // blue
-};
-
-export interface ToolCardProps extends React.HTMLAttributes<HTMLDivElement> {
-  title: string;
-  description?: string;
-  snapshot?: React.ReactNode;
-  colorKey: PaletteColorKey;
-  icon: ComponentType<LucideProps>;
-  onNavigate: () => void;
-}
-
-export default function ToolCard({
-  title,
-  description,
-  snapshot,
-  colorKey,
-  icon: IconComponent,
-  onNavigate,
-  className,
-  ...props
-}: ToolCardProps) {
-  const rgbValues = PALETTE_COLORS[colorKey];
-
-  return (
-    <div
-      style={{
-        ['--tool-color' as string]: rgbValues,
-      }}
-      /* 💡 核心修复点：
-        - 坚决不用 h-full 或固定高度，锁死 h-auto（高度自适应流），配合 py-4 px-4 牢牢把内容包裹在卡片体内。
-        - 废除原先会乱飘的内联 style 属性擦写，全权放权给 Tailwind 的声明式 hover 变体。
-      */
-      className={cn(
-        'group relative rounded-xl border border-border/70 bg-card text-card-foreground p-4 h-auto flex flex-col items-stretch justify-start gap-3 shadow-sm select-none box-border',
-        'hover:bg-muted/30',
-        'hover:border-[rgba(var(--tool-color),0.45)]',
-        'hover:shadow-[0_8px_24px_-8px_rgba(var(--tool-color),0.14)] dark:hover:shadow-[0_8px_30px_-10px_rgba(var(--tool-color),0.25)]',
-        className,
-      )}
-      {...props}
-    >
-      {/* 上半部分：核心信息交互排版轴 */}
-      <div className="flex items-center justify-between w-full relative min-w-0 min-h-[44px]">
-        <div className="flex gap-3 items-center min-w-0 flex-1 pr-2">
-          {/* 左侧圆形图标容器 */}
-          <div
-            className={cn(
-              'flex items-center justify-center w-10 h-10 rounded-xl shrink-0',
-              'bg-[rgba(var(--tool-color),0.08)] dark:bg-[rgba(var(--tool-color),0.12)]',
-              'text-[rgb(var(--tool-color))]',
-            )}
-          >
-            <IconComponent className="h-5 w-5 shrink-0" />
-          </div>
-
-          {/* 中间文字描述区：利用 flex-1 min-w-0 防御文本过长发生恶性撑开 */}
-          <div className="flex-1 min-w-0 flex flex-col">
-            <h4 className="font-bold text-sm tracking-tight text-foreground leading-snug">
-              {title}
-            </h4>
-            {description && (
-              <p className="text-[11px] font-medium text-muted-foreground/90 mt-0.5 leading-normal w-full truncate">
-                {description}
-              </p>
-            )}
-          </div>
-        </div>
-
-        {/* 右侧指示小箭头 */}
-        <div className="text-muted-foreground/40 group-hover:text-[rgb(var(--tool-color))] p-1 shrink-0 group-hover:translate-x-0.5">
-          <ChevronRight className="h-4 w-4" />
-        </div>
-
-        {/* 覆盖整个上半部分的绝对定位隐形跳转层（A11y 无障碍标准合规） */}
-        <button
-          type="button"
-          onClick={onNavigate}
-          aria-label={`进入 ${title}`}
-          className="absolute inset-0 w-full h-full cursor-pointer bg-transparent border-none opacity-0 focus-visible:outline-none"
-        />
-      </div>
-
-      {/* 下半部分：未来的动态预览沙箱独立承载区 */}
-      {snapshot != null && (
-        <div className="mt-1 pt-3 border-t border-dashed border-border/80 w-full relative z-10 select-text">
-          {snapshot}
-        </div>
-      )}
-    </div>
-  );
-}
-
-ToolCard.displayName = 'ToolCard';

src/pages/Dashboard/index.tsx

@@ -1,29 +1,24 @@
 import { useRouter } from '@/providers/RouterProvider';
 import { getFeatureByKey } from '@/config/features';
 import type { PageType } from '@/types/storage';
-import { useMemo } from 'react';
 import { useI18n } from '@/utils/chromeI18n';
 import { cn } from '@/lib/utils';
 
-export default function DashboardPage() {
+export default function Index() {
   const { navigateTo, visiblePages, pageOrder, recentlyUsedTools } = useRouter();
   const { t } = useI18n(['features']);
 
-  const visibleSet = useMemo(() => new Set<string>(visiblePages), [visiblePages]);
+  const visibleSet = new Set<string>(visiblePages);
 
-  const visibleFeatures = useMemo(() => {
-    return pageOrder
-      .filter((key) => visibleSet.has(key))
-      .map((key) => ({ key, feature: getFeatureByKey(key) }))
-      .filter((item) => item.feature?.themeColorKey && item.feature.icon != null);
-  }, [pageOrder, visibleSet]);
+  const visibleFeatures = pageOrder
+    .filter((key) => visibleSet.has(key))
+    .map((key) => ({ key, feature: getFeatureByKey(key) }))
+    .filter((item) => item.feature?.themeColorKey && item.feature.icon != null);
 
-  const recentFeatures = useMemo(() => {
-    return recentlyUsedTools
-      .filter((key) => visibleSet.has(key))
-      .map((key) => ({ key, feature: getFeatureByKey(key) }))
-      .filter((item) => item.feature?.themeColorKey && item.feature.icon != null);
-  }, [recentlyUsedTools, visibleSet]);
+  const recentFeatures = recentlyUsedTools
+    .filter((key) => visibleSet.has(key))
+    .map((key) => ({ key, feature: getFeatureByKey(key) }))
+    .filter((item) => item.feature?.themeColorKey && item.feature.icon != null);
 
   const showRecent = recentFeatures.length > 0;
 

src/pages/JsonTools/JsonConvertSection.tsx

@@ -1,7 +1,7 @@
 import React, { useEffect, useMemo, useState } from 'react';
 import { useI18n } from '@/utils/chromeI18n';
-import { formatByteSize } from '@/utils/textStatistics';
-import CopyButton from '@/components/CopyButton';
+import { formatBytes } from '@/utils/format';
+import { CopyButton } from '@/components/CopyButton';
 import TextInputArea from '@/components/TextInputArea';
 import { validateJson } from '@/utils/jsonFormatter';
 import { cn } from '@/lib/utils';
@@ -96,14 +96,14 @@ export default function JsonConvertSection({
                 <span>
                   {t('jsonFormat:originalSize')}:{' '}
                   <span className="font-semibold text-foreground/80">
-                    {formatByteSize(result.originalBytes)}
+                    {formatBytes(result.originalBytes)}
                   </span>
                 </span>
                 <span className="text-border/60">|</span>
                 <span>
                   {t('jsonFormat:formattedSize')}:{' '}
                   <span className="font-semibold text-foreground/80">
-                    {formatByteSize(result.outputBytes)}
+                    {formatBytes(result.outputBytes)}
                   </span>
                 </span>
               </div>

src/pages/JsonTools/JsonFormatSection.tsx

@@ -6,8 +6,8 @@ import {
   type JsonFormatResult,
   validateJson,
 } from '@/utils/jsonFormatter';
-import { formatByteSize } from '@/utils/textStatistics';
-import CopyButton from '@/components/CopyButton';
+import { formatBytes } from '@/utils/format';
+import { CopyButton } from '@/components/CopyButton';
 import SwitchButtonGroup from '@/components/SwitchButtonGroup';
 import TextInputArea from '@/components/TextInputArea';
 import { Checkbox } from '@/components/ui/checkbox';
@@ -127,14 +127,14 @@ export default function JsonFormatSection() {
                 <span>
                   {t('jsonFormat:originalSize')}:{' '}
                   <span className="font-semibold text-foreground/80">
-                    {formatByteSize(result.originalBytes)}
+                    {formatBytes(result.originalBytes)}
                   </span>
                 </span>
                 <span className="text-border/60">|</span>
                 <span>
                   {t('jsonFormat:formattedSize')}:{' '}
                   <span className="font-semibold text-foreground/80">
-                    {formatByteSize(result.formattedBytes)}
+                    {formatBytes(result.formattedBytes)}
                   </span>
                 </span>
               </div>

src/pages/JsonTools/constants.ts

@@ -0,0 +1,27 @@
+import type { JsonToolsPageMode } from '@/types/storage';
+
+export const VALID_PAGE_MODES: readonly JsonToolsPageMode[] = [
+  'diff',
+  'format',
+  'yaml',
+  'toml',
+  'minify',
+];
+
+export const isValidPageMode = (val: unknown): val is JsonToolsPageMode =>
+  typeof val === 'string' && (VALID_PAGE_MODES as readonly string[]).includes(val);
+
+export interface ParseState {
+  value: unknown;
+  error: string | null;
+}
+
+export const tryParse = (raw: string, invalidMsg: string): ParseState => {
+  const trimmed = raw.trim();
+  if (!trimmed) return { value: undefined, error: null };
+  try {
+    return { value: JSON.parse(trimmed), error: null };
+  } catch {
+    return { value: undefined, error: invalidMsg };
+  }
+};

src/pages/JsonTools/index.tsx

@@ -1,113 +1,39 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useI18n } from '@/utils/chromeI18n';
 import JsonDiffInput from './JsonDiffInput';
 import DiffResult from './DiffResult';
 import DiffNavigator from './DiffNavigator';
 import JsonFormatSection from './JsonFormatSection';
-import type { ConvertFunction } from './JsonConvertSection';
 import JsonConvertSection from './JsonConvertSection';
-import { diffJson } from './diffEngine';
-import { jsonToYaml } from '@/utils/jsonToYaml';
-import { jsonToToml } from '@/utils/jsonToToml';
-import { minifyJson } from '@/utils/jsonFormatter';
-import { useStorageState } from '@/utils/useStorageState';
-import type { JsonToolsPageMode } from '@/types/storage';
 import SwitchButtonGroup from '@/components/SwitchButtonGroup';
+import { useJsonTools } from './useJsonTools';
+import type { JsonToolsPageMode } from '@/types/storage';
 import type { ViewMode } from './types';
 
-interface ParseState {
-  value: unknown;
-  error: string | null;
-}
-
-const tryParse = (raw: string, invalidMsg: string): ParseState => {
-  const trimmed = raw.trim();
-  if (!trimmed) return { value: undefined, error: null };
-  try {
-    return { value: JSON.parse(trimmed), error: null };
-  } catch {
-    return { value: undefined, error: invalidMsg };
-  }
-};
-
-const VALID_PAGE_MODES: readonly JsonToolsPageMode[] = ['diff', 'format', 'yaml', 'toml', 'minify'];
-const isValidPageMode = (val: unknown): val is JsonToolsPageMode =>
-  typeof val === 'string' && (VALID_PAGE_MODES as readonly string[]).includes(val);
-
 type PageMode = JsonToolsPageMode;
 
 export default function Index() {
   const { t } = useI18n(['jsonDiff', 'jsonFormat']);
-  const [pageMode, setPageMode] = useStorageState('jsonTools/pageMode', 'diff', isValidPageMode);
-
-  // Debounce input
-  const [leftInput, setLeftInput] = useState('');
-  const [rightInput, setRightInput] = useState('');
-
-  // Debounced values
-  const [debouncedLeft, setDebouncedLeft] = useState('');
-  const [debouncedRight, setDebouncedRight] = useState('');
-
-  useEffect(() => {
-    const handle = setTimeout(() => {
-      setDebouncedLeft(leftInput);
-      setDebouncedRight(rightInput);
-    }, 250);
-    return () => clearTimeout(handle);
-  }, [leftInput, rightInput]);
-
-  // Parse debounced inputs
-  const parseState = useMemo(() => {
-    const invalidMsg = t('jsonDiff:invalidJson');
-    return {
-      left: tryParse(debouncedLeft, invalidMsg),
-      right: tryParse(debouncedRight, invalidMsg),
-    };
-  }, [debouncedLeft, debouncedRight, t]);
-
-  const leftError = parseState.left.error;
-  const rightError = parseState.right.error;
-
-  const [viewMode, setViewMode] = useState<ViewMode>('sideBySide');
-  const [currentDiffIndex, setCurrentDiffIndex] = useState(0);
-
-  // Real-time diff computation
-  const diffResult = useMemo(() => {
-    const { left, right } = parseState;
-    if (left.error || right.error || debouncedLeft.trim() === '' || debouncedRight.trim() === '') {
-      return null;
-    }
-    return diffJson(left.value, right.value);
-  }, [parseState, debouncedLeft, debouncedRight]);
-
-  const total = diffResult?.diffPaths.length ?? 0;
-
-  const handlePrev = useCallback(() => {
-    if (total === 0) return;
-    setCurrentDiffIndex((idx) => (idx - 1 + total) % total);
-  }, [total]);
-
-  const handleNext = useCallback(() => {
-    if (total === 0) return;
-    setCurrentDiffIndex((idx) => (idx + 1) % total);
-  }, [total]);
-
-  const activePath = diffResult && total > 0 ? diffResult.diffPaths[currentDiffIndex] : undefined;
-
-  const yamlConvert: ConvertFunction = useCallback((text: string) => {
-    const r = jsonToYaml(text);
-    return { output: r.output, originalBytes: r.originalBytes, outputBytes: r.outputBytes };
-  }, []);
-
-  const tomlConvert: ConvertFunction = useCallback((text: string) => {
-    const r = jsonToToml(text);
-    return { output: r.output, originalBytes: r.originalBytes, outputBytes: r.outputBytes };
-  }, []);
-
-  const minifyConvert: ConvertFunction = useCallback((text: string) => {
-    const r = minifyJson(text);
-    return { output: r.minified, originalBytes: r.originalBytes, outputBytes: r.minifiedBytes };
-  }, []);
+  const {
+    pageMode,
+    setPageMode,
+    leftInput,
+    rightInput,
+    setLeftInput,
+    setRightInput,
+    leftError,
+    rightError,
+    viewMode,
+    setViewMode,
+    diffResult,
+    total,
+    currentDiffIndex,
+    handlePrev,
+    handleNext,
+    activePath,
+    yamlConvert,
+    tomlConvert,
+    minifyConvert,
+  } = useJsonTools();
 
   return (
     <div className="p-4 w-full flex flex-col space-y-4 min-h-[500px] select-none">
@@ -144,10 +70,7 @@ export default function Index() {
               label={t('jsonDiff:leftLabel')}
               placeholder={t('jsonDiff:leftPlaceholder')}
               value={leftInput}
-              onChange={(val) => {
-                setLeftInput(val);
-                setCurrentDiffIndex(0);
-              }}
+              onChange={setLeftInput}
               error={leftError}
               minRows={9}
             />
@@ -155,10 +78,7 @@ export default function Index() {
               label={t('jsonDiff:rightLabel')}
               placeholder={t('jsonDiff:rightPlaceholder')}
               value={rightInput}
-              onChange={(val) => {
-                setRightInput(val);
-                setCurrentDiffIndex(0);
-              }}
+              onChange={setRightInput}
               error={rightError}
               minRows={9}
             />

src/pages/JsonTools/useJsonTools.ts

@@ -0,0 +1,137 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useI18n } from '@/utils/chromeI18n';
+import { useStorageState } from '@/utils/useStorageState';
+import { diffJson } from './diffEngine';
+import { jsonToYaml } from '@/utils/jsonToYaml';
+import { jsonToToml } from '@/utils/jsonToToml';
+import { minifyJson } from '@/utils/jsonFormatter';
+import { isValidPageMode, tryParse } from './constants';
+import type { JsonToolsPageMode } from '@/types/storage';
+import type { ConvertFunction } from './JsonConvertSection';
+import type { ViewMode } from './types';
+
+export interface UseJsonToolsReturn {
+  pageMode: JsonToolsPageMode;
+  setPageMode: (mode: JsonToolsPageMode) => void;
+  // Diff mode state
+  leftInput: string;
+  rightInput: string;
+  setLeftInput: (val: string) => void;
+  setRightInput: (val: string) => void;
+  leftError: string | null;
+  rightError: string | null;
+  viewMode: ViewMode;
+  setViewMode: (mode: ViewMode) => void;
+  diffResult: ReturnType<typeof diffJson> | null;
+  total: number;
+  currentDiffIndex: number;
+  handlePrev: () => void;
+  handleNext: () => void;
+  activePath: string | undefined;
+  // Convert functions
+  yamlConvert: ConvertFunction;
+  tomlConvert: ConvertFunction;
+  minifyConvert: ConvertFunction;
+}
+
+export function useJsonTools(): UseJsonToolsReturn {
+  const { t } = useI18n(['jsonDiff', 'jsonFormat']);
+  const [pageMode, setPageMode] = useStorageState('jsonTools/pageMode', 'diff', isValidPageMode);
+
+  // Diff inputs
+  const [leftInput, setLeftInput] = useState('');
+  const [rightInput, setRightInput] = useState('');
+  const [debouncedLeft, setDebouncedLeft] = useState('');
+  const [debouncedRight, setDebouncedRight] = useState('');
+
+  // Debounce
+  useEffect(() => {
+    const handle = setTimeout(() => {
+      setDebouncedLeft(leftInput);
+      setDebouncedRight(rightInput);
+    }, 250);
+    return () => clearTimeout(handle);
+  }, [leftInput, rightInput]);
+
+  // Parse debounced inputs
+  const parseState = useMemo(() => {
+    const invalidMsg = t('jsonDiff:invalidJson');
+    return {
+      left: tryParse(debouncedLeft, invalidMsg),
+      right: tryParse(debouncedRight, invalidMsg),
+    };
+  }, [debouncedLeft, debouncedRight, t]);
+
+  const leftError = parseState.left.error;
+  const rightError = parseState.right.error;
+
+  const [viewMode, setViewMode] = useState<ViewMode>('sideBySide');
+  const [currentDiffIndex, setCurrentDiffIndex] = useState(0);
+
+  // Real-time diff computation
+  const diffResult = useMemo(() => {
+    const { left, right } = parseState;
+    if (left.error || right.error || debouncedLeft.trim() === '' || debouncedRight.trim() === '') {
+      return null;
+    }
+    return diffJson(left.value, right.value);
+  }, [parseState, debouncedLeft, debouncedRight]);
+
+  const total = diffResult?.diffPaths.length ?? 0;
+
+  const handlePrev = useCallback(() => {
+    if (total === 0) return;
+    setCurrentDiffIndex((idx) => (idx - 1 + total) % total);
+  }, [total]);
+
+  const handleNext = useCallback(() => {
+    if (total === 0) return;
+    setCurrentDiffIndex((idx) => (idx + 1) % total);
+  }, [total]);
+
+  const activePath = diffResult && total > 0 ? diffResult.diffPaths[currentDiffIndex] : undefined;
+
+  // Convert functions
+  const yamlConvert: ConvertFunction = useCallback((text: string) => {
+    const r = jsonToYaml(text);
+    return { output: r.output, originalBytes: r.originalBytes, outputBytes: r.outputBytes };
+  }, []);
+
+  const tomlConvert: ConvertFunction = useCallback((text: string) => {
+    const r = jsonToToml(text);
+    return { output: r.output, originalBytes: r.originalBytes, outputBytes: r.outputBytes };
+  }, []);
+
+  const minifyConvert: ConvertFunction = useCallback((text: string) => {
+    const r = minifyJson(text);
+    return { output: r.minified, originalBytes: r.originalBytes, outputBytes: r.minifiedBytes };
+  }, []);
+
+  return {
+    pageMode,
+    setPageMode,
+    leftInput,
+    rightInput,
+    setLeftInput: (val: string) => {
+      setLeftInput(val);
+      setCurrentDiffIndex(0);
+    },
+    setRightInput: (val: string) => {
+      setRightInput(val);
+      setCurrentDiffIndex(0);
+    },
+    leftError,
+    rightError,
+    viewMode,
+    setViewMode,
+    diffResult,
+    total,
+    currentDiffIndex,
+    handlePrev,
+    handleNext,
+    activePath,
+    yamlConvert,
+    tomlConvert,
+    minifyConvert,
+  };
+}

src/pages/Jwt/JwtSection.tsx

@@ -0,0 +1,38 @@
+import { CopyButton } from '@/components/CopyButton';
+import { useI18n } from '@/utils/chromeI18n';
+import { stringifyJson } from '@/utils/jwt';
+import { cn } from '@/lib/utils';
+
+interface JwtSectionProps {
+  title: string;
+  content: unknown;
+  colorClass: string;
+  bgClass: string;
+  borderClass: string;
+}
+
+export default function JwtSection({
+  title,
+  content,
+  colorClass,
+  bgClass,
+  borderClass,
+}: JwtSectionProps) {
+  const { t } = useI18n('jwt');
+  return (
+    <div className={cn('p-4 rounded-xl border border-solid', bgClass, borderClass)}>
+      <div className="flex justify-between items-center mb-2 select-none">
+        <span className={cn('text-xs font-bold tracking-wider uppercase', colorClass)}>
+          {title}
+        </span>
+        <CopyButton
+          text={JSON.stringify(content)}
+          className="h-6 w-6 rounded-md border text-muted-foreground"
+        />
+      </div>
+      <pre className="m-0 p-3 bg-muted/30 dark:bg-muted/10 rounded-lg text-xs font-mono overflow-x-auto whitespace-pre-wrap break-all border border-border/50 text-foreground/90 leading-relaxed select-text">
+        {content ? stringifyJson(content) : t('jwt:invalidFormat')}
+      </pre>
+    </div>
+  );
+}

src/pages/Jwt/index.tsx

@@ -1,91 +1,31 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { parseJwt, stringifyJson } from '@/utils/jwt';
-import CopyButton from '@/components/CopyButton';
 import TextInputArea from '@/components/TextInputArea';
+import { CopyButton } from '@/components/CopyButton';
+import JwtSection from './JwtSection';
+import { useJwt } from './useJwt';
 import { useI18n } from '@/utils/chromeI18n';
-import { useContextMenuData } from '@/utils/useContextMenuData';
-import { cn } from '@/lib/utils';
-
-interface SectionProps {
-  title: string;
-  content: unknown;
-  colorClass: string;
-  bgClass: string;
-  borderClass: string;
-}
-
-const Section = ({ title, content, colorClass, bgClass, borderClass }: SectionProps) => {
-  const { t } = useI18n('jwt');
-  return (
-    <div className={cn('p-4 rounded-xl border border-solid', bgClass, borderClass)}>
-      <div className="flex justify-between items-center mb-2 select-none">
-        <span className={cn('text-xs font-bold tracking-wider uppercase', colorClass)}>
-          {title}
-        </span>
-        <CopyButton
-          text={JSON.stringify(content)}
-          className="h-6 w-6 rounded-md border text-muted-foreground"
-        />
-      </div>
-      <pre className="m-0 p-3 bg-muted/30 dark:bg-muted/10 rounded-lg text-xs font-mono overflow-x-auto whitespace-pre-wrap break-all border border-border/50 text-foreground/90 leading-relaxed select-text">
-        {content ? stringifyJson(content) : t('jwt:invalidFormat')}
-      </pre>
-    </div>
-  );
-};
 
 export default function Index() {
   const { t } = useI18n(['jwt', 'jsonFormat']);
-  const [jwtInput, setJwtInput] = useState('');
-
-  // 2. 防抖中转管道：切断高频键盘敲击时的红色语法闪烁
-  const [debouncedInput, setDebouncedInput] = useState('');
-
-  useEffect(() => {
-    const handle = setTimeout(() => {
-      setDebouncedInput(jwtInput);
-    }, 200);
-    return () => clearTimeout(handle);
-  }, [jwtInput]);
-
-  const handleContextMenuData = useCallback((payload: string) => {
-    const cleaned = payload.replace(/^Bearer\s*/i, '').trim();
-    setJwtInput(cleaned);
-  }, []);
-
-  useContextMenuData({ featureKey: 'jwt', onData: handleContextMenuData });
-
-  const result = useMemo(() => {
-    if (!debouncedInput.trim()) {
-      return null;
-    }
-    return parseJwt(debouncedInput);
-  }, [debouncedInput]);
+  const { jwtInput, result, handleChange, handleClear } = useJwt();
 
   return (
     <div className="p-4 w-full flex flex-col space-y-4 select-none">
       <div className="flex flex-col gap-4">
-        {/* 输入终端 */}
         <TextInputArea
           minRows={5}
           maxRows={10}
           placeholder={t('jwt_placeholder')}
           value={jwtInput}
-          onChange={(val) => {
-            const cleaned = val.replace(/^Bearer\s*/i, '').trim();
-            setJwtInput(cleaned);
-          }}
+          onChange={handleChange}
           allowCopy={true}
           showClear={true}
           externalError={result?.error || undefined}
-          onClear={() => setJwtInput('')}
+          onClear={handleClear}
         />
 
-        {/* 解码看板结果展现 */}
         {result && !result.error && (
           <div className="flex flex-col gap-4">
-            {/* Header 分区：完美致敬 JWT.io 的鲜艳色彩，同时实现黑夜暗化自适应 */}
-            <Section
+            <JwtSection
               title={t('jwt:headerTitle')}
               content={result.header}
               colorClass="text-[#fb015b] dark:text-rose-400"
@@ -93,16 +33,14 @@ export default function Index() {
               bgClass="bg-[#fb015b]/5 dark:bg-rose-500/5"
             />
 
-            {/* Payload 分区 */}
-            <Section
+            <JwtSection
               title={t('jwt:payloadTitle')}
               content={result.payload}
-              colorClass="text-[#a03aff] dark:text-purple-400" // 针对暗黑模式略微调高对比度
+              colorClass="text-[#a03aff] dark:text-purple-400"
               borderClass="border-[#a03aff]/20 dark:border-purple-500/20"
               bgClass="bg-[#a03aff]/5 dark:bg-purple-500/5"
             />
 
-            {/* Signature 签名区：完全对齐标准的 shadcn 骨架阶度 */}
             <div className="p-4 rounded-xl border border-border bg-secondary/40 shadow-sm">
               <div className="flex justify-between items-center mb-2">
                 <span className="text-xs font-bold tracking-wider text-muted-foreground/90 uppercase">
@@ -120,7 +58,6 @@ export default function Index() {
           </div>
         )}
 
-        {/* 当解析错误时的干净中性引导拦截 */}
         {result?.error && (
           <div className="p-6 rounded-xl bg-muted/30 border border-dashed border-border text-center">
             <p className="text-xs font-semibold text-muted-foreground/80">

src/pages/Jwt/useJwt.ts

@@ -0,0 +1,43 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useContextMenuData } from '@/utils/useContextMenuData';
+import { parseJwt } from '@/utils/jwt';
+import type { JwtResult } from '@/utils/jwt';
+
+export interface UseJwtReturn {
+  jwtInput: string;
+  result: JwtResult | null;
+  handleChange: (val: string) => void;
+  handleClear: () => void;
+}
+
+export function useJwt(): UseJwtReturn {
+  const [jwtInput, setJwtInput] = useState('');
+  const [debouncedInput, setDebouncedInput] = useState('');
+
+  // 防抖管道
+  useEffect(() => {
+    const handle = setTimeout(() => setDebouncedInput(jwtInput), 200);
+    return () => clearTimeout(handle);
+  }, [jwtInput]);
+
+  // 右键菜单数据
+  const handleContextMenuData = useCallback((payload: string) => {
+    setJwtInput(payload.replace(/^Bearer\s*/i, '').trim());
+  }, []);
+
+  useContextMenuData({ featureKey: 'jwt', onData: handleContextMenuData });
+
+  // 响应式解析
+  const result = useMemo(() => {
+    if (!debouncedInput.trim()) return null;
+    return parseJwt(debouncedInput);
+  }, [debouncedInput]);
+
+  const handleChange = useCallback((val: string) => {
+    setJwtInput(val.replace(/^Bearer\s*/i, '').trim());
+  }, []);
+
+  const handleClear = useCallback(() => setJwtInput(''), []);
+
+  return { jwtInput, result, handleChange, handleClear };
+}

src/pages/QrCode/__tests__/index.test.tsx

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { fireEvent, render, screen } from '@testing-library/react';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import QrCodePage from '../index';
 
 vi.mock('lucide-react', async (importOriginal) => {
@@ -7,6 +7,8 @@ vi.mock('lucide-react', async (importOriginal) => {
   return {
     ...actual,
     QrCode: () => <div data-testid="mock-lucide-qrcode">Icon</div>,
+    Pencil: () => <div data-testid="mock-lucide-pencil">Icon</div>,
+    Loader2: () => <div data-testid="mock-lucide-loader">Icon</div>,
   };
 });
 
@@ -32,20 +34,29 @@ vi.mock('@/components/ImageUploader', () => ({
   default: () => <div data-testid="image-uploader">ImageUploader</div>,
 }));
 
-vi.mock('qrious', () => ({
-  default: vi.fn().mockImplementation(() => ({
-    toDataURL: () => 'data:image/png;base64,mock',
-  })),
-}));
+vi.mock('qrious', () => {
+  return {
+    default: class QRious {
+      constructor() {
+        return {
+          toDataURL: () => 'data:image/png;base64,mock',
+        };
+      }
+    },
+  };
+});
 
 describe('QrCodePage', () => {
   beforeEach(() => {
     vi.clearAllMocks();
   });
 
-  it('应该默认渲染生成模式', () => {
+  it('应该默认渲染生成模式的输入态', () => {
     render(<QrCodePage />);
-    expect(screen.getByTestId('qr-code-preview')).toBeInTheDocument();
+    expect(screen.getByText('输入 URL 或文本')).toBeInTheDocument();
+    expect(screen.getByText('生成二维码')).toBeInTheDocument();
+    // 输入态应该隐藏二维码预览
+    expect(screen.queryByTestId('qr-code-preview')).not.toBeInTheDocument();
   });
 
   it('应该渲染模式切换按钮', () => {
@@ -58,27 +69,139 @@ describe('QrCodePage', () => {
     render(<QrCodePage />);
     fireEvent.click(screen.getByText('二维码转文本'));
     expect(screen.getByTestId('image-uploader')).toBeInTheDocument();
-    expect(screen.queryByTestId('qr-code-preview')).not.toBeInTheDocument();
   });
 
-  it('切换回生成模式应该渲染 QrCodePreview', () => {
+  it('切换回生成模式应该渲染输入态', () => {
     render(<QrCodePage />);
     // 先切换到解析模式
     fireEvent.click(screen.getByText('二维码转文本'));
-    expect(screen.getByTestId('image-uploader')).toBeInTheDocument();
     // 再切换回生成模式
     fireEvent.click(screen.getByText('文本转二维码'));
-    expect(screen.getByTestId('qr-code-preview')).toBeInTheDocument();
+    expect(screen.getByText('输入 URL 或文本')).toBeInTheDocument();
+    expect(screen.getByText('生成二维码')).toBeInTheDocument();
   });
 
-  it('应该渲染输入区域的系统标签（对齐新版 Label 机制）', () => {
+  it('应该渲染输入区域的系统标签', () => {
     render(<QrCodePage />);
     expect(screen.getByText('输入 URL 或文本')).toBeInTheDocument();
   });
 
-  it('应该渲染双翼响应式卡片网格布局', () => {
-    const { container } = render(<QrCodePage />);
-    const gridContainer = container.querySelector('.grid');
-    expect(gridContainer).toBeInTheDocument();
+  it('输入态应该显示生成按钮', () => {
+    render(<QrCodePage />);
+    const generateButton = screen.getByText('生成二维码');
+    expect(generateButton).toBeInTheDocument();
+    expect(generateButton).toBeDisabled(); // 空输入时按钮应该禁用
+  });
+
+  it('有输入内容时生成按钮应该可用', () => {
+    render(<QrCodePage />);
+    const textarea = screen.getByPlaceholderText('请输入 URL 或文本内容，将自动生成二维码');
+    fireEvent.change(textarea, { target: { value: 'https://example.com' } });
+
+    const generateButton = screen.getByText('生成二维码');
+    expect(generateButton).not.toBeDisabled();
+  });
+
+  it('点击生成按钮应该切换到预览态', async () => {
+    render(<QrCodePage />);
+
+    // 输入文本
+    const textarea = screen.getByPlaceholderText('请输入 URL 或文本内容，将自动生成二维码');
+    fireEvent.change(textarea, { target: { value: 'https://example.com' } });
+
+    // 点击生成按钮
+    const generateButton = screen.getByText('生成二维码');
+    fireEvent.click(generateButton);
+
+    // 验证切换到预览态
+    await waitFor(() => {
+      expect(screen.getByText('原始文本')).toBeInTheDocument();
+      expect(screen.getByText('编辑')).toBeInTheDocument();
+      expect(screen.queryByText('生成二维码')).not.toBeInTheDocument();
+      // 预览态应该显示二维码
+      expect(screen.getByTestId('qr-code-preview')).toBeInTheDocument();
+    });
+  });
+
+  it('预览态应该显示截断的文本', async () => {
+    render(<QrCodePage />);
+
+    // 输入长文本
+    const longText =
+      'https://example.com/very/long/path/that/should/be/truncated/in/the/preview/because/it/exceeds/the/maximum/length';
+    const textarea = screen.getByPlaceholderText('请输入 URL 或文本内容，将自动生成二维码');
+    fireEvent.change(textarea, { target: { value: longText } });
+
+    // 点击生成按钮
+    fireEvent.click(screen.getByText('生成二维码'));
+
+    // 验证显示截断的文本（80字符 + "..."）
+    const truncatedText = longText.slice(0, 80) + '...';
+    await waitFor(() => {
+      expect(screen.getByText(truncatedText)).toBeInTheDocument();
+    });
+  });
+
+  it('预览态应该显示完整的短文本', async () => {
+    render(<QrCodePage />);
+
+    // 输入短文本
+    const shortText = 'https://example.com';
+    const textarea = screen.getByPlaceholderText('请输入 URL 或文本内容，将自动生成二维码');
+    fireEvent.change(textarea, { target: { value: shortText } });
+
+    // 点击生成按钮
+    fireEvent.click(screen.getByText('生成二维码'));
+
+    // 验证显示完整文本
+    await waitFor(() => {
+      expect(screen.getByText(shortText)).toBeInTheDocument();
+    });
+  });
+
+  it('点击编辑按钮应该返回输入态', async () => {
+    render(<QrCodePage />);
+
+    // 输入文本并生成
+    const textarea = screen.getByPlaceholderText('请输入 URL 或文本内容，将自动生成二维码');
+    fireEvent.change(textarea, { target: { value: 'https://example.com' } });
+    fireEvent.click(screen.getByText('生成二维码'));
+
+    // 等待生成完成
+    await waitFor(() => {
+      expect(screen.getByText('编辑')).toBeInTheDocument();
+    });
+
+    // 点击编辑按钮
+    fireEvent.click(screen.getByText('编辑'));
+
+    // 验证返回输入态
+    expect(screen.getByText('输入 URL 或文本')).toBeInTheDocument();
+    expect(screen.getByText('生成二维码')).toBeInTheDocument();
+    expect(screen.queryByText('编辑')).not.toBeInTheDocument();
+    // 输入态应该隐藏二维码预览
+    expect(screen.queryByTestId('qr-code-preview')).not.toBeInTheDocument();
+  });
+
+  it('返回编辑态应该保留上次输入的内容', async () => {
+    render(<QrCodePage />);
+
+    // 输入文本并生成
+    const textarea = screen.getByPlaceholderText('请输入 URL 或文本内容，将自动生成二维码');
+    fireEvent.change(textarea, { target: { value: 'https://example.com' } });
+    fireEvent.click(screen.getByText('生成二维码'));
+
+    // 等待生成完成
+    await waitFor(() => {
+      expect(screen.getByText('编辑')).toBeInTheDocument();
+    });
+
+    // 点击编辑按钮
+    fireEvent.click(screen.getByText('编辑'));
+
+    // 验证输入框保留了上次的内容
+    const textareaAfterEdit =
+      screen.getByPlaceholderText('请输入 URL 或文本内容，将自动生成二维码');
+    expect(textareaAfterEdit).toHaveValue('https://example.com');
   });
 });

src/pages/QrCode/components/GeneratePanel.tsx

@@ -1,51 +1,114 @@
+import { Loader2, Pencil, QrCode } from 'lucide-react';
 import TextInputArea from '@/components/TextInputArea';
 import QrCodePreview from '@/components/QrCodePreview';
 import { useI18n } from '@/utils/chromeI18n';
 import { useQrCodeContext } from '../contexts/QrCodeContext';
+import { Button } from '@/components/ui/button';
 import { Label } from '@/components/ui/label';
 import { cn } from '@/lib/utils';
 
+/** 文本预览的最大显示字符数 */
+const TEXT_PREVIEW_MAX_LENGTH = 80;
+
 export default function GeneratePanel() {
   const { t } = useI18n('qrCode');
-  const { generatorState, setTextToEncode, downloadQrCode, copyQrCode } = useQrCodeContext();
+  const {
+    generatorState,
+    setTextToEncode,
+    confirmGenerate,
+    backToEdit,
+    downloadQrCode,
+    copyQrCode,
+  } = useQrCodeContext();
 
-  return (
-    <div className="grid grid-cols-1 md:grid-cols-2 gap-6 w-full items-stretch select-none p-0.5">
-      <div
-        className={cn(
-          'border border-border rounded-xl bg-card text-card-foreground shadow-sm flex flex-col p-4',
-          'focus-within:ring-1 focus-within:ring-ring focus-within:border-ring',
-        )}
-      >
-        <div className="flex flex-col space-y-2.5 h-full">
-          <Label className="text-[10px] font-bold text-muted-foreground/90 uppercase tracking-wider select-none pl-0.5">
-            {t('qrCode:urlInputLabel')}
-          </Label>
+  const isInputStep = generatorState.step === 'input';
+  const hasText = generatorState.textToEncode.trim().length > 0;
+
+  /** 截断文本用于预览显示 */
+  const getTruncatedText = (text: string) => {
+    if (text.length <= TEXT_PREVIEW_MAX_LENGTH) return text;
+    return text.slice(0, TEXT_PREVIEW_MAX_LENGTH) + '...';
+  };
+
+  // 输入态：只显示输入框和生成按钮
+  if (isInputStep) {
+    return (
+      <div className="w-full select-none p-0.5">
+        <div
+          className={cn(
+            'border border-border rounded-xl bg-card text-card-foreground shadow-sm flex flex-col p-4',
+            'focus-within:ring-1 focus-within:ring-ring focus-within:border-ring',
+          )}
+        >
+          <div className="flex flex-col space-y-2.5">
+            <Label className="text-[10px] font-bold text-muted-foreground/90 uppercase tracking-wider select-none pl-0.5">
+              {t('qrCode:urlInputLabel')}
+            </Label>
 
-          <div className="flex-1 min-h-0">
             <TextInputArea
               value={generatorState.textToEncode}
               onChange={setTextToEncode}
               placeholder={t('qrCode:urlInputPlaceholder')}
               showCount={true}
               showClear={true}
-              allowCopy={true}
+              allowCopy={false}
               minRows={6}
               maxRows={12}
               externalError={generatorState.inputError || undefined}
               onClear={() => setTextToEncode('')}
             />
+
+            <Button
+              onClick={confirmGenerate}
+              disabled={!hasText || generatorState.generating}
+              className="w-full"
+            >
+              {generatorState.generating ? (
+                <>
+                  <Loader2 className="w-4 h-4 mr-2 animate-spin" />
+                  {t('qrCode:generating')}
+                </>
+              ) : (
+                <>
+                  <QrCode className="w-4 h-4 mr-2" />
+                  {t('qrCode:generateButton')}
+                </>
+              )}
+            </Button>
           </div>
         </div>
       </div>
+    );
+  }
 
-      <div className="flex flex-col h-full">
-        <QrCodePreview
-          qrCodeDataUrl={generatorState.qrCodeDataUrl}
-          onDownload={downloadQrCode}
-          onCopy={copyQrCode}
-        />
+  // 预览态：显示文本预览 + 二维码（紧凑布局，适配popup窗口）
+  return (
+    <div className="w-full select-none p-0.5 flex flex-col">
+      {/* 文本预览区域（固定高度，单行显示） */}
+      <div className="border border-border rounded-xl bg-card text-card-foreground shadow-sm p-3 mb-3">
+        <div className="flex items-center justify-between mb-1.5">
+          <Label className="text-[10px] font-bold text-muted-foreground/90 uppercase tracking-wider select-none pl-0.5">
+            {t('qrCode:textPreviewLabel')}
+          </Label>
+          <Button variant="ghost" size="sm" onClick={backToEdit} className="h-6 px-2 text-xs">
+            <Pencil className="w-3 h-3 mr-1" />
+            {t('qrCode:editButton')}
+          </Button>
+        </div>
+        <div
+          className="text-sm text-foreground bg-muted/50 rounded-md px-3 py-2 cursor-default line-clamp-1"
+          title={generatorState.savedText}
+        >
+          {getTruncatedText(generatorState.savedText)}
+        </div>
       </div>
+
+      {/* 二维码预览区域（自适应剩余空间） */}
+      <QrCodePreview
+        qrCodeDataUrl={generatorState.qrCodeDataUrl}
+        onDownload={downloadQrCode}
+        onCopy={copyQrCode}
+      />
     </div>
   );
 }

src/pages/QrCode/components/ParsePanel.tsx

@@ -1,17 +1,20 @@
 import { useCallback, useEffect } from 'react';
+import { RefreshCw } from 'lucide-react';
+import { toast } from 'sonner';
 import TextInputArea from '@/components/TextInputArea';
 import ImageUploader from '@/components/ImageUploader';
-import { useSnackbar } from '@/components/GlobalSnackbar';
 import { useI18n } from '@/utils/chromeI18n';
 import { useQrCodeContext } from '../contexts/QrCodeContext';
+import { Button } from '@/components/ui/button';
 import { Label } from '@/components/ui/label';
 import { cn } from '@/lib/utils';
 
 export default function ParsePanel() {
   const { t } = useI18n('qrCode');
-  const { showMessage } = useSnackbar();
   const { parserState, setParserState, handleFileChange, handleClearFile } = useQrCodeContext();
 
+  const hasFile = parserState.selectedFile !== null;
+
   // 全局粘贴事件监听
   const handlePaste = useCallback(
     async (e: ClipboardEvent) => {
@@ -24,7 +27,7 @@ export default function ParsePanel() {
           const file = items[i].getAsFile();
           if (file) {
             handleFileChange(file);
-            showMessage(t('qrCode:imagePasted'), { severity: 'success', autoHideDuration: 1000 });
+            toast.success(t('qrCode:imagePasted'));
           }
           return;
         }
@@ -38,14 +41,14 @@ export default function ParsePanel() {
           const blob = await response.blob();
           const file = new File([blob], 'pasted-image.png', { type: blob.type });
           handleFileChange(file);
-          showMessage(t('qrCode:imagePasted'), { severity: 'success', autoHideDuration: 1000 });
+          toast.success(t('qrCode:imagePasted'));
         } catch (error) {
           console.error('处理 Base64 图片失败:', error);
-          showMessage(t('qrCode:imagePasteError'), { severity: 'error', autoHideDuration: 3000 });
+          toast.error(t('qrCode:imagePasteError'));
         }
       }
     },
-    [handleFileChange, showMessage, t],
+    [handleFileChange, t],
   );
 
   useEffect(() => {
@@ -55,9 +58,10 @@ export default function ParsePanel() {
     };
   }, [handlePaste]);
 
-  return (
-    <div className="grid grid-cols-1 md:grid-cols-2 gap-6 w-full items-stretch select-none p-0.5">
-      <div className="flex flex-col h-full">
+  // 未上传图片：只显示上传区域
+  if (!hasFile) {
+    return (
+      <div className="w-full select-none p-0.5">
         <ImageUploader
           selectedFile={parserState.selectedFile}
           onFileChange={handleFileChange}
@@ -68,30 +72,60 @@ export default function ParsePanel() {
           onDraggingChange={(dragging) => setParserState((prev) => ({ ...prev, dragging }))}
         />
       </div>
+    );
+  }
 
+  // 已上传图片：显示图片预览 + 解析结果
+  return (
+    <div className="w-full select-none p-0.5 flex flex-col">
+      {/* 图片预览区域（小图预览） */}
+      <div className="border border-border rounded-xl bg-card text-card-foreground shadow-sm p-3 mb-3">
+        <div className="flex items-center justify-between mb-1.5">
+          <Label className="text-[10px] font-bold text-muted-foreground/90 uppercase tracking-wider select-none pl-0.5">
+            {t('qrCode:uploadedImage')}
+          </Label>
+          <Button variant="ghost" size="sm" onClick={handleClearFile} className="h-6 px-2 text-xs">
+            <RefreshCw className="w-3 h-3 mr-1" />
+            {t('qrCode:reuploadButton')}
+          </Button>
+        </div>
+        <div className="flex items-center gap-3 bg-muted/50 rounded-md p-2">
+          <img
+            src={parserState.previewUrl}
+            alt="Uploaded QR Code"
+            className="w-16 h-16 object-contain rounded"
+          />
+          <div className="flex-1 min-w-0">
+            <p className="text-sm text-foreground truncate">{parserState.selectedFile?.name}</p>
+            {parserState.parsing && (
+              <p className="text-xs text-primary animate-pulse mt-1">{t('qrCode:parsing')}</p>
+            )}
+          </div>
+        </div>
+      </div>
+
+      {/* 解析结果区域 */}
       <div
         className={cn(
           'border border-border rounded-xl bg-card text-card-foreground shadow-sm flex flex-col p-4',
           'focus-within:ring-1 focus-within:ring-ring focus-within:border-ring',
         )}
       >
-        <div className="flex flex-col space-y-2.5 h-full">
+        <div className="flex flex-col space-y-2.5">
           <Label className="text-[10px] font-bold text-muted-foreground/90 uppercase tracking-wider pl-0.5">
             {t('qrCode:resultLabel')}
           </Label>
 
-          <div className="flex-1 min-h-0">
-            <TextInputArea
-              value={parserState.decodedResult}
-              readOnly={true}
-              showClear={false}
-              allowCopy={true}
-              placeholder=""
-              minRows={6}
-              maxRows={12}
-              externalError={parserState.parseError || undefined}
-            />
-          </div>
+          <TextInputArea
+            value={parserState.decodedResult}
+            readOnly={true}
+            showClear={false}
+            allowCopy={true}
+            placeholder={parserState.parsing ? '' : t('qrCode:resultPlaceholder')}
+            minRows={4}
+            maxRows={8}
+            externalError={parserState.parseError || undefined}
+          />
         </div>
       </div>
     </div>

src/pages/QrCode/contexts/QrCodeContext.ts

@@ -8,6 +8,10 @@ export interface QrCodeContextValue {
 
   generatorState: QrCodeGeneratorState;
   setTextToEncode: (text: string) => void;
+  /** 显式触发生成二维码并切换到预览态 */
+  confirmGenerate: () => void;
+  /** 返回编辑态，保留上次输入内容 */
+  backToEdit: () => void;
 
   downloadQrCode: () => void;
   copyQrCode: () => Promise<void>;

src/pages/QrCode/hooks/useQrCode.ts

@@ -1,23 +1,93 @@
-import { useCallback, useMemo, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 import QRious from 'qrious';
-import { useSnackbar } from '@/components/GlobalSnackbar';
+import { toast } from 'sonner';
 import { parseQrCodeFromFile } from '@/utils/qrCodeParser';
 import { useContextMenuData } from '@/utils/useContextMenuData';
 import { useI18n } from '@/utils/chromeI18n';
-import { useDebounce } from '@/utils/useDebounce';
 import type { QrCodeContextValue } from '../contexts/QrCodeContext';
 import type { QrCodeGeneratorState, QrCodeMode, QrCodeParserState } from '../types';
 
+/** 防抖延迟时间（毫秒） */
+const DEBOUNCE_DELAY = 500;
+
+/** 检测文本是否为URL格式 */
+function isUrl(text: string): boolean {
+  const trimmed = text.trim();
+  if (!trimmed) return false;
+
+  // 检查是否以 http:// 或 https:// 开头
+  if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) {
+    return true;
+  }
+
+  // 检查是否为域名格式（包含.且不以特殊字符开头）
+  const domainPattern = /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z]{2,})+([/:].*)?$/;
+  return domainPattern.test(trimmed);
+}
+
+/** 检测URL是否为图片格式 */
+function isImageUrl(url: string): boolean {
+  const trimmedUrl = url.trim().toLowerCase();
+
+  // 检查是否为 data:image 格式
+  if (trimmedUrl.startsWith('data:image/')) {
+    return true;
+  }
+
+  // 检查是否包含图片扩展名
+  const imageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg', '.ico'];
+  if (imageExtensions.some((ext) => trimmedUrl.includes(ext))) {
+    return true;
+  }
+
+  // 检查URL路径中是否包含图片相关关键词
+  const imageKeywords = ['/image/', '/img/', '/photo/', '/pic/', '/upload/'];
+  if (imageKeywords.some((keyword) => trimmedUrl.includes(keyword))) {
+    return true;
+  }
+
+  return false;
+}
+
+/** 生成二维码的核心逻辑 */
+function generateQrCodeDataUrl(text: string): string {
+  const trimmedText = text.trim();
+  if (!trimmedText) return '';
+
+  try {
+    let url = trimmedText;
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+      url = 'https://' + url;
+    }
+
+    const isDark = document.documentElement.classList.contains('dark');
+
+    const qr = new QRious({
+      value: url,
+      size: 260,
+      level: 'H',
+      foreground: isDark ? '#f3f4f6' : '#0f172a',
+      background: isDark ? 'transparent' : '#ffffff',
+    });
+
+    return qr.toDataURL();
+  } catch (error) {
+    console.error('QR code generation failed:', error);
+    return '';
+  }
+}
+
 export function useQrCode(): QrCodeContextValue {
   const { t } = useI18n('qrCode');
-  const { showMessage } = useSnackbar();
 
   const [mode, setMode] = useState<QrCodeMode>('generate');
 
-  const [generatorState, setGeneratorState] = useState<
-    Omit<QrCodeGeneratorState, 'generating' | 'qrCodeDataUrl'>
-  >({
+  const [generatorState, setGeneratorState] = useState<QrCodeGeneratorState>({
+    step: 'input',
     textToEncode: '',
+    savedText: '',
+    qrCodeDataUrl: '',
+    generating: false,
     inputError: '',
   });
 
@@ -30,52 +100,196 @@ export function useQrCode(): QrCodeContextValue {
     dragging: false,
   });
 
-  const debouncedTextToEncode = useDebounce(generatorState.textToEncode, 200);
+  const debounceTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
-  const qrCodeDataUrl = useMemo(() => {
-    const text = debouncedTextToEncode.trim();
-    if (!text) return '';
+  // 清除防抖定时器
+  useEffect(() => {
+    return () => {
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
+      }
+    };
+  }, []);
 
-    try {
-      let url = text;
-      if (!url.startsWith('http://') && !url.startsWith('https://')) {
-        url = 'https://' + url;
+  /** 自动检测URL并生成二维码 */
+  const autoGenerateIfUrl = useCallback(
+    (text: string) => {
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
       }
 
-      const isDark = document.documentElement.classList.contains('dark');
+      if (!isUrl(text)) {
+        return;
+      }
 
-      const qr = new QRious({
-        value: url,
-        size: 260,
-        level: 'H',
-        foreground: isDark ? '#f3f4f6' : '#0f172a',
-        background: isDark ? 'transparent' : '#ffffff',
-      });
+      debounceTimerRef.current = setTimeout(() => {
+        setGeneratorState((prev) => ({ ...prev, generating: true, inputError: '' }));
 
-      return qr.toDataURL();
-    } catch (error) {
-      console.error('QR code generation sync task failed:', error);
-      return '';
-    }
-  }, [debouncedTextToEncode]);
+        const qrCodeDataUrl = generateQrCodeDataUrl(text);
 
-  const fullGeneratorState = useMemo<QrCodeGeneratorState>(
-    () => ({
-      ...generatorState,
-      qrCodeDataUrl,
-      generating: false,
-    }),
-    [generatorState, qrCodeDataUrl],
+        if (qrCodeDataUrl) {
+          setGeneratorState((prev) => ({
+            ...prev,
+            step: 'preview',
+            savedText: text.trim(),
+            qrCodeDataUrl,
+            generating: false,
+          }));
+        } else {
+          setGeneratorState((prev) => ({
+            ...prev,
+            generating: false,
+            inputError: t('qrCode:generateError'),
+          }));
+        }
+      }, DEBOUNCE_DELAY);
+    },
+    [t],
   );
 
-  const setTextToEncode = useCallback((text: string) => {
-    setGeneratorState((prev) => ({ ...prev, textToEncode: text, inputError: '' }));
+  const setTextToEncode = useCallback(
+    (text: string) => {
+      setGeneratorState((prev) => ({ ...prev, textToEncode: text, inputError: '' }));
+      autoGenerateIfUrl(text);
+    },
+    [autoGenerateIfUrl],
+  );
+
+  /** 手动触发生成二维码（用于非URL文本） */
+  const confirmGenerate = useCallback(() => {
+    const text = generatorState.textToEncode.trim();
+
+    if (!text) {
+      setGeneratorState((prev) => ({ ...prev, inputError: t('qrCode:inputRequired') }));
+      toast.error(t('qrCode:inputRequired'));
+      return;
+    }
+
+    // 先设置 loading 状态，让 React 渲染加载动画
+    setGeneratorState((prev) => ({ ...prev, generating: true, inputError: '' }));
+
+    // 延迟到下一帧生成，确保 loading 状态先被渲染显示
+    setTimeout(() => {
+      const qrCodeDataUrl = generateQrCodeDataUrl(text);
+
+      if (!qrCodeDataUrl) {
+        setGeneratorState((prev) => ({
+          ...prev,
+          generating: false,
+          inputError: t('qrCode:generateError'),
+        }));
+        toast.error(t('qrCode:generateError'));
+        return;
+      }
+
+      setGeneratorState((prev) => ({
+        ...prev,
+        step: 'preview',
+        savedText: text,
+        qrCodeDataUrl,
+        generating: false,
+      }));
+    }, 0);
+  }, [generatorState.textToEncode, t]);
+
+  /** 返回编辑态，保留上次输入内容 */
+  const backToEdit = useCallback(() => {
+    if (debounceTimerRef.current) {
+      clearTimeout(debounceTimerRef.current);
+    }
+    setGeneratorState((prev) => ({
+      ...prev,
+      step: 'input',
+      textToEncode: prev.savedText,
+      qrCodeDataUrl: '',
+      inputError: '',
+    }));
   }, []);
 
-  const handleContextMenuData = useCallback((payload: string) => {
-    setMode('generate');
-    setGeneratorState((prev) => ({ ...prev, textToEncode: payload, inputError: '' }));
-  }, []);
+  /** 从图片URL解析二维码 */
+  const parseQrCodeFromUrl = useCallback(
+    async (imageUrl: string) => {
+      try {
+        setParserState((prev) => ({
+          ...prev,
+          parsing: true,
+          parseError: '',
+          decodedResult: '',
+          previewUrl: imageUrl,
+          selectedFile: null,
+        }));
+
+        // 从URL获取图片并转换为File对象
+        const response = await fetch(imageUrl);
+        const blob = await response.blob();
+        const file = new File([blob], 'qrcode-image.png', { type: blob.type });
+
+        setParserState((prev) => ({ ...prev, selectedFile: file }));
+
+        const result = await parseQrCodeFromFile(file);
+
+        if (result.success && result.data) {
+          setParserState((prev) => ({ ...prev, decodedResult: result.data! }));
+          toast.success(t('qrCode:parseSuccess'));
+        } else {
+          const errorMsg = result.error || t('qrCode:noQrDetected');
+          setParserState((prev) => ({ ...prev, parseError: errorMsg }));
+          toast.error(errorMsg);
+        }
+      } catch (error) {
+        console.error('解析图片二维码失败:', error);
+        const errorMsg = error instanceof Error ? error.message : t('qrCode:parseError');
+        setParserState((prev) => ({ ...prev, parseError: errorMsg }));
+        toast.error(errorMsg);
+      } finally {
+        setParserState((prev) => ({ ...prev, parsing: false }));
+      }
+    },
+    [t],
+  );
+
+  /** 右键菜单传入URL时，自动生成二维码或解析图片 */
+  const handleContextMenuData = useCallback(
+    (payload: string) => {
+      // 检测是否为图片URL，如果是则切换到解析模式
+      if (isImageUrl(payload)) {
+        setMode('parse');
+        void parseQrCodeFromUrl(payload);
+        return;
+      }
+
+      // 非图片URL，生成二维码
+      setMode('generate');
+
+      // 直接生成二维码，无需等待
+      const qrCodeDataUrl = generateQrCodeDataUrl(payload);
+
+      if (qrCodeDataUrl) {
+        // 生成成功，直接跳转到预览态
+        setGeneratorState((prev) => ({
+          ...prev,
+          step: 'preview',
+          textToEncode: payload,
+          savedText: payload.trim(),
+          qrCodeDataUrl,
+          generating: false,
+          inputError: '',
+        }));
+      } else {
+        // 生成失败，停留在输入态，显示文本供用户编辑
+        setGeneratorState((prev) => ({
+          ...prev,
+          step: 'input',
+          textToEncode: payload,
+          savedText: '',
+          qrCodeDataUrl: '',
+          generating: false,
+          inputError: '',
+        }));
+      }
+    },
+    [parseQrCodeFromUrl],
+  );
 
   useContextMenuData({ featureKey: 'qrCode', onData: handleContextMenuData });
 
@@ -89,39 +303,39 @@ export function useQrCode(): QrCodeContextValue {
 
         if (result.success && result.data) {
           setParserState((prev) => ({ ...prev, decodedResult: result.data! }));
-          showMessage(t('qrCode:parseSuccess'), { severity: 'success', autoHideDuration: 1000 });
+          toast.success(t('qrCode:parseSuccess'));
         } else {
           const errorMsg = result.error || t('qrCode:noQrDetected');
           setParserState((prev) => ({ ...prev, parseError: errorMsg }));
-          showMessage(errorMsg, { severity: 'error', autoHideDuration: 3000 });
+          toast.error(errorMsg);
         }
       } catch (error) {
         console.error('解析二维码失败:', error);
         const errorMsg = error instanceof Error ? error.message : t('qrCode:parseError');
         setParserState((prev) => ({ ...prev, parseError: errorMsg }));
-        showMessage(errorMsg, { severity: 'error', autoHideDuration: 3000 });
+        toast.error(errorMsg);
       } finally {
         setParserState((prev) => ({ ...prev, parsing: false }));
       }
     },
-    [t, showMessage],
+    [t],
   );
 
   const downloadQrCode = useCallback(() => {
-    if (!qrCodeDataUrl) return;
+    if (!generatorState.qrCodeDataUrl) return;
 
     const link = document.createElement('a');
-    link.href = qrCodeDataUrl;
+    link.href = generatorState.qrCodeDataUrl;
     link.download = 'qrcode.png';
     link.click();
-    showMessage(t('qrCode:qrCodeDownloadSuccess'), { severity: 'success', autoHideDuration: 1000 });
-  }, [qrCodeDataUrl, showMessage, t]);
+    toast.success(t('qrCode:qrCodeDownloadSuccess'));
+  }, [generatorState.qrCodeDataUrl, t]);
 
   const copyQrCode = useCallback(async () => {
-    if (!qrCodeDataUrl) return;
+    if (!generatorState.qrCodeDataUrl) return;
 
     try {
-      const response = await fetch(qrCodeDataUrl);
+      const response = await fetch(generatorState.qrCodeDataUrl);
       const blob = await response.blob();
 
       await navigator.clipboard.write([
@@ -130,12 +344,12 @@ export function useQrCode(): QrCodeContextValue {
         }),
       ]);
 
-      showMessage(t('qrCode:qrCodeCopySuccess'), { severity: 'success', autoHideDuration: 1000 });
+      toast.success(t('qrCode:qrCodeCopySuccess'));
     } catch (error) {
       console.error('复制二维码失败:', error);
-      showMessage(t('qrCode:copyError'), { severity: 'error', autoHideDuration: 3000 });
+      toast.error(t('qrCode:copyError'));
     }
-  }, [qrCodeDataUrl, showMessage, t]);
+  }, [generatorState.qrCodeDataUrl, t]);
 
   const handleFileChange = useCallback(
     (file: File) => {
@@ -179,8 +393,10 @@ export function useQrCode(): QrCodeContextValue {
   return {
     mode,
     setMode,
-    generatorState: fullGeneratorState,
+    generatorState,
     setTextToEncode,
+    confirmGenerate,
+    backToEdit,
     parseQrCode,
     downloadQrCode,
     copyQrCode,

src/pages/QrCode/types.ts

@@ -5,16 +5,23 @@
 /** 二维码功能核心主路由模式 */
 export type QrCodeMode = 'generate' | 'parse';
 
+/** 生成器的操作步骤 */
+export type GeneratorStep = 'input' | 'preview';
+
 /** * 二维码生成器的状态
- * 💡 架构优化：保留与全局 Context 骨架契合的形态，
- * 外部依然可以流畅读取这些状态，但在新架构下运行效率和稳定性大幅提升！
+ * 💡 架构优化：采用两步操作模式（输入态 → 预览态），
+ * 用户显式点击生成按钮后才生成二维码，体验更清晰！
  */
 export interface QrCodeGeneratorState {
+  /** 当前操作步骤：输入态或预览态 */
+  step: GeneratorStep;
   /** 受控的输入源文本（支持 URL 或任意文本快照） */
   textToEncode: string;
-  /** 由防抖源文本流在单次渲染内存中同步派生出的二维码 Base64 Data URL */
+  /** 保存的文本快照，用于预览态展示和编辑态回填 */
+  savedText: string;
+  /** 由用户显式触发生成的二维码 Base64 Data URL */
   qrCodeDataUrl: string;
-  /** 是否正在生成（流式架构下已默认为恒定 false 的非阻塞快照，保留作为 UI 骨架兼容） */
+  /** 是否正在生成 */
   generating: boolean;
   /** 输入文本校验或底层画布崩溃的错误提示信息 */
   inputError: string;

src/pages/README.md

@@ -113,14 +113,6 @@ Base64 编解码工具，支持文本/文件/图片三种模式。
 | `TextMode.tsx`               | 文本模式              |
 | `Base64ConverterSection.tsx` | 文件/图片通用转换区域 |
 
-### MarkdownToHtml/
-
-Markdown 转 HTML 工具，支持分栏/预览/源码三种视图模式。
-
-### HtmlToMarkdown/
-
-HTML 转 Markdown 工具，支持分栏/预览/Markdown 三种视图模式。
-
 ### RightClickRestorer/
 
 右键菜单恢复工具，解除网站对右键的限制。
@@ -130,11 +122,32 @@ HTML 转 Markdown 工具，支持分栏/预览/Markdown 三种视图模式。
 | `index.tsx`                | 页面 UI       |
 | `useRightClickRestorer.ts` | 业务逻辑 Hook |
 
+### TestDataGenerator/
+
+测试数据生成器，支持可视化字段配置、规则复用、Web Worker 批量生成和 JSON/CSV 导出。
+
+| 文件/目录                    | 用途                                              |
+| ---------------------------- | ------------------------------------------------- |
+| `index.tsx`                  | 主页面，管理字段配置、规则标签页和生成结果        |
+| `hooks/useGenerator.ts`      | Worker 生命周期与消息通信，暴露生成/取消/清理操作 |
+| `components/FieldList.tsx`   | 字段列表、拖拽排序、虚拟滚动和规则保存入口        |
+| `components/FieldEditor.tsx` | 字段名称、生成器、参数、必填/空值率/唯一性配置    |
+| `components/RuleManager.tsx` | 规则搜索、加载、编辑、复制、删除、导入和导出      |
+| `components/ExportPanel.tsx` | 生成结果复制和 JSON/CSV 下载                      |
+
+约束与注意事项：
+
+- 字段数量最多 40 个（`FieldList.MAX_FIELDS`）。
+- 生成数量为 1 ~ 100,000，预设值包含 50、100、1,000、5,000、10,000。
+- 大批量生成通过 `src/workers/generator.worker.ts` 执行，避免阻塞 UI；Worker 每 1,000 条或结束时回传进度。
+- 规则通过 `src/utils/ruleStorage.ts` 存入 `localStorage`，最多保存 20 条规则。
+- 内置生成器位于 `src/lib/generators/`，按个人信息、业务数据、技术数据、基础类型分类。
+
 ## 新增页面
 
 1. 在 `types/storage.d.ts` 添加 `PageType` 联合类型成员
 2. 在 `config/features.tsx` 的 `FEATURES` 数组添加配置
 3. 在 `pages/` 创建页面目录（遵循上述结构）
-4. 在 `i18n/locales/{zh,en}/features.json` 添加翻译
+4. 在 `public/_locales/zh_CN/messages.json` 添加 Chrome i18n 翻译
 5. 如需新权限，更新 `wxt.config.ts`
 6. 添加对应的单元测试

src/pages/RightClickRestorer/index.tsx

@@ -5,7 +5,7 @@ import { Shield, ShieldCheck, MousePointerClick, AlertTriangle } from 'lucide-re
 import { useRightClickRestorer } from './useRightClickRestorer';
 import { useI18n } from '@/utils/chromeI18n';
 
-export default function RightClickRestorerPage() {
+export default function Index() {
   const { t } = useI18n('rightClickRestorer');
   const { domain, isLoading, isUnlocked, isUnsupported, unlock } = useRightClickRestorer();
 

src/pages/RightClickRestorer/useRightClickRestorer.ts

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from 'react';
+import { useEffect, useState } from 'react';
 import { MessageAction, sendMessageToContent } from '@/utils/messages';
 
 const UNSUPPORTED_PROTOCOLS = new Set([
@@ -39,17 +39,10 @@ export function useRightClickRestorer(): UseRightClickRestorerReturn {
         const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
         const url = tab?.url;
 
-        if (url) {
-          try {
-            setDomain(new URL(url).hostname);
-          } catch {
-            setDomain('');
-          }
-        }
+        setDomain(url ? new URL(url).hostname : '');
 
         if (isUnsupportedPage(url)) {
           setIsUnsupported(true);
-          setIsLoading(false);
           return;
         }
 
@@ -67,7 +60,7 @@ export function useRightClickRestorer(): UseRightClickRestorerReturn {
     void load();
   }, []);
 
-  const unlock = useCallback(async () => {
+  async function unlock() {
     if (isUnsupported) return;
 
     try {
@@ -78,7 +71,7 @@ export function useRightClickRestorer(): UseRightClickRestorerReturn {
     } catch (err) {
       console.error('[RightClickRestorer] Failed to unlock:', err);
     }
-  }, [isUnsupported]);
+  }
 
   return {
     domain,

src/pages/StorageCleaner/AutoRefreshToggle.tsx

@@ -1,8 +1,8 @@
 /**
- * 自动刷新开关组件
+ * 自动刷新开关行
  *
- * 用于 StorageCleaner 页面，控制是否自动刷新存储数据列表。
- * 以卡片形式展示，左侧为标签文本，右侧为 shadcn/ui Switch 开关。
+ * 用于 StorageCleaner 页面的操作区域内（非独立卡片），
+ * 控制清理后是否自动刷新页面。左侧为标签文本，右侧为 shadcn/ui Switch 开关。
  *
  * @example
  * ```tsx
@@ -48,15 +48,14 @@ export default function AutoRefreshToggle({
   return (
     <div
       className={cn(
-        'w-full p-4 rounded-xl border border-border bg-card text-card-foreground shadow-sm flex justify-between items-center',
+        'w-full px-3.5 py-3 border-t border-border flex justify-between items-center',
         className,
       )}
       {...props}
     >
-      {/* Label 与 Switch 通过 htmlFor + id 关联，支持点击文字触发开关 */}
       <Label
         htmlFor="auto-refresh-switch"
-        className="text-sm font-bold text-foreground cursor-pointer select-none tracking-tight"
+        className="text-xs font-bold text-muted-foreground/90 cursor-pointer select-none tracking-wide uppercase"
       >
         {t('storageCleaner:autoRefresh')}
       </Label>

src/pages/StorageCleaner/CleaningResult.tsx

@@ -14,7 +14,7 @@ export default function CleaningResult({ result, className, ...props }: Cleaning
 
   if (!result) return null;
 
-  const isSuccess = result.success;
+  const isSuccess = result.overallSuccess;
 
   return (
     <div className={cn('w-full', className)} {...props}>

src/pages/StorageCleaner/OptionItem.tsx

@@ -1,59 +1,63 @@
 import React from 'react';
-import { formatSize } from '@/utils/storageCleaner';
+import { formatBytes } from '@/utils/format';
 import { useI18n } from '@/utils/chromeI18n';
 import { cn } from '@/lib/utils';
-// 引入官方的 Checkbox 原子组件
+import type { StorageSizeInfo } from './useStorageCleaner';
 import { Checkbox } from '@/components/ui/checkbox';
 
 interface OptionItemProps extends React.HTMLAttributes<HTMLDivElement> {
   labelKey: string;
   checked: boolean;
-  size?: number;
-  isCount?: boolean;
+  sizeInfo?: StorageSizeInfo;
   onChange: () => void;
 }
 
 export default function OptionItem({
   labelKey,
   checked,
-  size,
-  isCount = false,
+  sizeInfo,
   onChange,
   className,
   ...props
 }: OptionItemProps) {
   const { t } = useI18n('storageCleaner');
 
+  const sizeValue = sizeInfo?.value;
+  const isCount = sizeInfo?.displayType === 'count';
+
   return (
     <div
       onClick={onChange}
       className={cn(
-        'flex justify-between items-center py-2.5 px-3.5 rounded-xl border cursor-pointer select-none',
+        'flex justify-between items-center py-2.5 px-3.5 rounded-lg border cursor-pointer select-none transition-colors',
         checked
           ? 'bg-primary/5 border-primary/30 shadow-sm'
-          : 'bg-transparent border-transparent hover:bg-muted/70',
+          : 'bg-transparent border-transparent hover:bg-muted/50',
         className,
       )}
       {...props}
     >
-      {/* 左侧数据区域 */}
-      <div className="flex-1 min-w-0 mr-4">
+      <div className="flex-1 min-w-0 mr-3">
         <span
           className={cn(
-            'block text-xs font-semibold leading-tight truncate',
-            checked ? 'text-foreground font-bold' : 'text-foreground/80',
+            'block text-xs font-semibold leading-tight truncate transition-colors',
+            checked ? 'text-foreground' : 'text-foreground/75',
           )}
         >
           {t(labelKey)}
         </span>
 
-        {/* 底部容量大小或计数标识 */}
-        {size !== undefined && size > 0 ? (
-          <span className="block text-[10px] font-mono font-medium text-muted-foreground/80 mt-0.5 tabular-nums">
-            {isCount ? `${size} ${t('storageCleaner:countUnit')}` : formatSize(size)}
+        {sizeValue !== undefined && sizeValue > 0 ? (
+          <span
+            className={cn(
+              'block text-[10px] font-mono font-medium mt-0.5 tabular-nums transition-colors',
+              checked ? 'text-primary/70' : 'text-muted-foreground/70',
+            )}
+          >
+            {isCount ? `${sizeValue} ${t('storageCleaner:countUnit')}` : formatBytes(sizeValue)}
           </span>
         ) : (
-          <span className="block text-[10px] font-medium text-muted-foreground/60 mt-0.5 italic">
+          <span className="block text-[10px] font-medium text-muted-foreground/50 mt-0.5 italic">
             {t('storageCleaner:noData')}
           </span>
         )}

src/pages/StorageCleaner/StorageOptionsGrid.tsx

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { StorageCleanerOptions } from '@/types/storage';
+import type { StorageSizeInfo } from './useStorageCleaner';
 import OptionItem from './OptionItem';
 import { useI18n } from '@/utils/chromeI18n';
 import { cn } from '@/lib/utils';
@@ -8,7 +9,7 @@ import { Label } from '@/components/ui/label';
 
 interface StorageOptionsGridProps extends React.HTMLAttributes<HTMLDivElement> {
   options: StorageCleanerOptions;
-  sizes: Record<string, number>;
+  sizes: Record<string, StorageSizeInfo>;
   allSelected: boolean;
   someSelected: boolean;
   onOptionChange: (key: keyof StorageCleanerOptions) => void;
@@ -27,13 +28,13 @@ export default function StorageOptionsGrid({
 }: StorageOptionsGridProps) {
   const { t } = useI18n('storageCleaner');
 
-  const optionKeys: { key: keyof StorageCleanerOptions; isCount?: boolean }[] = [
-    { key: 'localStorage' },
-    { key: 'sessionStorage' },
-    { key: 'indexedDB' },
-    { key: 'cookies' },
-    { key: 'cacheStorage', isCount: true },
-    { key: 'serviceWorkers', isCount: true },
+  const optionKeys: (keyof StorageCleanerOptions)[] = [
+    'localStorage',
+    'sessionStorage',
+    'indexedDB',
+    'cookies',
+    'cacheStorage',
+    'serviceWorkers',
   ];
 
   const handleToggleAll = () => {
@@ -41,22 +42,15 @@ export default function StorageOptionsGrid({
   };
 
   return (
-    <div
-      className={cn(
-        'w-full rounded-xl border border-border bg-card text-card-foreground shadow-sm overflow-hidden',
-        className,
-      )}
-      {...props}
-    >
-      <div className="p-3">
-        <div className="grid grid-cols-2 gap-2.5 items-stretch">
-          {optionKeys.map(({ key, isCount }) => (
+    <div className={cn('w-full overflow-hidden', className)} {...props}>
+      <div className="px-3.5 pt-3.5 pb-2">
+        <div className="grid grid-cols-2 gap-2 items-stretch">
+          {optionKeys.map((key) => (
             <OptionItem
               key={key}
               labelKey={`storageCleaner:options.${key}`}
               checked={options[key]}
-              size={sizes[key]}
-              isCount={isCount}
+              sizeInfo={sizes[key]}
               onChange={() => onOptionChange(key)}
             />
           ))}
@@ -65,9 +59,9 @@ export default function StorageOptionsGrid({
 
       <div
         onClick={handleToggleAll}
-        className="border-t border-border flex justify-between items-center px-4 py-2.5 bg-muted/20 hover:bg-muted/50 cursor-pointer select-none"
+        className="border-t border-border flex justify-between items-center pl-3.5 pr-7 py-2.5 bg-muted/20 hover:bg-muted/40 cursor-pointer select-none transition-colors"
       >
-        <Label className="text-xs font-bold text-muted-foreground/90 cursor-pointer">
+        <Label className="text-xs font-bold text-muted-foreground/90 cursor-pointer tracking-wide uppercase">
           {t('storageCleaner:selectAll')}
         </Label>
 
@@ -75,7 +69,7 @@ export default function StorageOptionsGrid({
           checked={allSelected ? true : someSelected ? 'indeterminate' : false}
           onClick={(e) => e.stopPropagation()}
           onCheckedChange={(checked) => onSelectAll(checked === true)}
-          className="h-4 w-4 shrink-0 rounded border-input data-[state=checked]:bg-primary data-[state=indeterminate]:bg-primary"
+          className="h-4 w-4 shrink-0 rounded border-input data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground data-[state=indeterminate]:bg-muted-foreground/40"
         />
       </div>
     </div>

src/pages/StorageCleaner/index.tsx

@@ -1,6 +1,6 @@
 import { Loader2 } from 'lucide-react';
 import { Button } from '@/components/ui/button';
-import StorageCleanerConfirm from '@/pages/StorageCleaner/StorageCleanerConfirm';
+import StorageCleanerConfirm from './StorageCleanerConfirm';
 import { useStorageCleaner } from './useStorageCleaner';
 import StorageOptionsGrid from './StorageOptionsGrid';
 import AutoRefreshToggle from './AutoRefreshToggle';
@@ -47,37 +47,42 @@ export default function Index() {
   }
 
   return (
-    <div className="p-4 w-full flex flex-col space-y-3.5">
-      <StorageOptionsGrid
-        options={options}
-        sizes={sizes}
-        allSelected={allSelected}
-        someSelected={someSelected}
-        onOptionChange={handleOptionChange}
-        onSelectAll={handleSelectAll}
-      />
+    <div className="p-4 w-full flex flex-col space-y-4 select-none">
+      {/* 操作区域卡片 */}
+      <div className="w-full rounded-xl border border-border bg-card text-card-foreground shadow-sm overflow-hidden">
+        <StorageOptionsGrid
+          options={options}
+          sizes={sizes}
+          allSelected={allSelected}
+          someSelected={someSelected}
+          onOptionChange={handleOptionChange}
+          onSelectAll={handleSelectAll}
+        />
 
-      <AutoRefreshToggle
-        reloadAfterClean={reloadAfterClean}
-        onChange={handleReloadAfterCleanChange}
-      />
+        <AutoRefreshToggle
+          reloadAfterClean={reloadAfterClean}
+          onChange={handleReloadAfterCleanChange}
+        />
 
-      <Button
-        variant="destructive"
-        size="default"
-        onClick={() => setShowConfirm(true)}
-        disabled={isButtonDisabled}
-        className="w-full h-10 font-bold shadow-sm text-sm tracking-wide"
-      >
-        {loading ? (
-          <>
-            <Loader2 className="mr-2 h-4 w-4 animate-spin" />
-            {t('storageCleaner:cleaning')}
-          </>
-        ) : (
-          t('storageCleaner:cleanNow')
-        )}
-      </Button>
+        <div className="px-3.5 pb-3.5 pt-1">
+          <Button
+            variant="destructive"
+            size="default"
+            onClick={() => setShowConfirm(true)}
+            disabled={isButtonDisabled}
+            className="w-full h-10 font-bold shadow-sm text-sm tracking-wide"
+          >
+            {loading ? (
+              <>
+                <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+                {t('storageCleaner:cleaning')}
+              </>
+            ) : (
+              t('storageCleaner:cleanNow')
+            )}
+          </Button>
+        </div>
+      </div>
 
       <CleaningResult result={result} />
 

src/pages/StorageCleaner/useStorageCleaner.ts

@@ -16,7 +16,6 @@ import {
   getSessionStorageSize,
   isRestrictedUrl,
 } from '@/utils/storageCleaner';
-import { MessageAction, sendMessage } from '@/utils/messages';
 import { useI18n } from '@/utils/chromeI18n';
 import { toast } from 'sonner';
 
@@ -34,18 +33,22 @@ const DEFAULT_PREFERENCES: StorageCleanerPreferences = {
   selectedTypes: DEFAULT_OPTIONS,
 };
 
+export interface StorageSizeInfo {
+  value: number;
+  displayType: 'bytes' | 'count';
+}
+
 export interface UseStorageCleanerReturn {
-  domain: string;
   error: string;
   isInitializing: boolean;
   options: StorageCleanerOptions;
-  sizes: Record<string, number>;
+  sizes: Record<string, StorageSizeInfo>;
   reloadAfterClean: boolean;
   loading: boolean;
   result: CleaningResult | null;
   showConfirm: boolean;
   setShowConfirm: (show: boolean) => void;
-  totalSize: number;
+  totalBytes: number;
   allSelected: boolean;
   someSelected: boolean;
 
@@ -57,11 +60,10 @@ export interface UseStorageCleanerReturn {
 
 export function useStorageCleaner(): UseStorageCleanerReturn {
   const { t } = useI18n(['storageCleaner', 'common']);
-  const [domain, setDomain] = useState<string>('');
   const [error, setError] = useState<string>('');
   const [isInitializing, setIsInitializing] = useState<boolean>(true);
   const [options, setOptions] = useState<StorageCleanerOptions>(DEFAULT_OPTIONS);
-  const [sizes, setSizes] = useState<Record<string, number>>({});
+  const [sizes, setSizes] = useState<Record<string, StorageSizeInfo>>({});
   const [reloadAfterClean, setReloadAfterClean] = useState<boolean>(true);
   const [loading, setLoading] = useState<boolean>(false);
   const [result, setResult] = useState<CleaningResult | null>(null);
@@ -102,7 +104,6 @@ export function useStorageCleaner(): UseStorageCleanerReturn {
       setError('');
       const url = tab.url;
       const tabId = tab.id!;
-      setDomain(new URL(url).hostname);
 
       const [savedPrefs, cSize, lsSize, ssSize, idbSize, cacheCount, swCount] = await Promise.all([
         storageUtil.get('storageCleaner/preferences', DEFAULT_PREFERENCES),
@@ -122,12 +123,12 @@ export function useStorageCleaner(): UseStorageCleanerReturn {
       }
 
       setSizes({
-        cookies: cSize,
-        localStorage: lsSize,
-        sessionStorage: ssSize,
-        indexedDB: idbSize,
-        cacheStorage: cacheCount,
-        serviceWorkers: swCount,
+        cookies: { value: cSize, displayType: 'bytes' },
+        localStorage: { value: lsSize, displayType: 'bytes' },
+        sessionStorage: { value: ssSize, displayType: 'bytes' },
+        indexedDB: { value: idbSize, displayType: 'bytes' },
+        cacheStorage: { value: cacheCount, displayType: 'count' },
+        serviceWorkers: { value: swCount, displayType: 'count' },
       });
     } finally {
       if (currentRequestId === requestIdRef.current) {
@@ -217,9 +218,9 @@ export function useStorageCleaner(): UseStorageCleanerReturn {
       const cleaningResult = await clearStorage(tab.id, tab.url, options);
       setResult(cleaningResult);
 
-      if (reloadAfterClean && cleaningResult.success) {
+      if (reloadAfterClean && cleaningResult.overallSuccess) {
         toast.success(t('storageCleaner:cleanSuccessReload'));
-        await sendMessage(MessageAction.RELOAD_TAB, { tabId: tab.id, delay: 1000 });
+        await chrome.tabs.reload(tab.id);
       } else {
         await loadInfo();
       }
@@ -231,13 +232,10 @@ export function useStorageCleaner(): UseStorageCleanerReturn {
     }
   }, [options, reloadAfterClean, loadInfo, t]);
 
-  const totalSize = useMemo(() => {
-    return (
-      (sizes.cookies || 0) +
-      (sizes.localStorage || 0) +
-      (sizes.sessionStorage || 0) +
-      (sizes.indexedDB || 0)
-    );
+  const totalBytes = useMemo(() => {
+    return Object.values(sizes).reduce((acc, s) => {
+      return s.displayType === 'bytes' ? acc + (s.value || 0) : acc;
+    }, 0);
   }, [sizes]);
 
   const selectionMetrics = useMemo(() => {
@@ -248,7 +246,6 @@ export function useStorageCleaner(): UseStorageCleanerReturn {
   }, [options]);
 
   return {
-    domain,
     error,
     isInitializing,
     options,
@@ -258,7 +255,7 @@ export function useStorageCleaner(): UseStorageCleanerReturn {
     result,
     showConfirm,
     setShowConfirm,
-    totalSize,
+    totalBytes,
     allSelected: selectionMetrics.all,
     someSelected: selectionMetrics.some,
     handleReloadAfterCleanChange,

src/pages/TestDataGenerator/components/DataPreview.tsx

@@ -0,0 +1,114 @@
+/**
+ * 数据预览组件
+ * 展示一条示例数据，展示数据结构
+ */
+
+import { useMemo } from 'react';
+import { FileJson, FileText } from 'lucide-react';
+import { useI18n } from '@/utils/chromeI18n';
+import { getGeneratorById } from '@/lib/generators';
+import type { FieldConfig } from '@/types/testDataGenerator';
+
+interface DataPreviewProps {
+  fields: FieldConfig[];
+}
+
+/** JSON 语法高亮渲染 */
+function JsonHighlight({ data }: { data: Record<string, unknown> }) {
+  const formatted = useMemo(() => {
+    const lines: { indent: string; key?: string; value: string; isLast: boolean }[] = [];
+    const entries = Object.entries(data);
+
+    entries.forEach(([key, value], index) => {
+      const isLast = index === entries.length - 1;
+      const formattedValue =
+        value === null ? 'null' : typeof value === 'string' ? `"${value}"` : String(value);
+      lines.push({ indent: '  ', key, value: formattedValue, isLast });
+    });
+
+    return lines;
+  }, [data]);
+
+  return (
+    <pre className="text-sm font-mono leading-relaxed">
+      <span className="text-muted-foreground">{'{'}</span>
+      {formatted.map((line, i) => (
+        <div key={i} className="flex">
+          <span className="text-muted-foreground">{line.indent}</span>
+          <span className="text-blue-500 dark:text-blue-400">&quot;{line.key}&quot;</span>
+          <span className="text-muted-foreground">{': '}</span>
+          <span className={getValueColor(line.value)}>{line.value}</span>
+          {!line.isLast && <span className="text-muted-foreground">,</span>}
+        </div>
+      ))}
+      <span className="text-muted-foreground">{'}'}</span>
+    </pre>
+  );
+}
+
+/** 根据值类型返回颜色类名 */
+function getValueColor(value: string): string {
+  if (value === 'null') return 'text-muted-foreground';
+  if (value.startsWith('"')) return 'text-emerald-600 dark:text-emerald-400';
+  if (/^\d+$/.test(value)) return 'text-amber-600 dark:text-amber-400';
+  if (value === 'true' || value === 'false') return 'text-purple-600 dark:text-purple-400';
+  return 'text-foreground';
+}
+
+export default function DataPreview({ fields }: DataPreviewProps) {
+  const { t } = useI18n('testDataGenerator');
+
+  // 生成一条示例数据
+  const sampleData = useMemo(() => {
+    if (fields.length === 0) return null;
+
+    const record: Record<string, unknown> = {};
+    for (const field of fields) {
+      // 非必填字段预览显示 null
+      if (!field.required) {
+        record[field.name] = null;
+        continue;
+      }
+      const generator = getGeneratorById(field.generatorId);
+      if (generator) {
+        record[field.name] = generator.generate(field.params);
+      } else {
+        record[field.name] = null;
+      }
+    }
+    return record;
+  }, [fields]);
+
+  if (!sampleData) {
+    return (
+      <div className="flex flex-col items-center justify-center h-full text-center">
+        <FileJson className="h-8 w-8 text-muted-foreground/30 mb-2" />
+        <p className="text-xs text-muted-foreground/50">{t('testDataGenerator_noDataHint')}</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex flex-col h-full">
+      {/* 示例标签 */}
+      <div className="flex items-center justify-between mb-3">
+        <div className="flex items-center gap-2">
+          <div className="h-5 w-5 rounded bg-primary/10 flex items-center justify-center">
+            <FileText className="h-3 w-3 text-primary" />
+          </div>
+          <span className="text-xs font-medium text-muted-foreground">
+            {t('testDataGenerator_sampleData')}
+          </span>
+        </div>
+        <span className="text-[10px] text-muted-foreground/50 bg-muted px-1.5 py-0.5 rounded">
+          {Object.keys(sampleData).length} {t('testDataGenerator_fields')}
+        </span>
+      </div>
+
+      {/* 示例数据展示 */}
+      <div className="flex-1 min-h-0 overflow-auto rounded-lg bg-zinc-950 dark:bg-zinc-900 p-4">
+        <JsonHighlight data={sampleData} />
+      </div>
+    </div>
+  );
+}

src/pages/TestDataGenerator/components/ExportPanel.tsx

@@ -0,0 +1,81 @@
+/**
+ * 导出面板组件
+ * 提供复制、下载 JSON、下载 CSV 选项
+ */
+
+import { Copy, Download } from 'lucide-react';
+import { toast } from 'sonner';
+import { Button } from '@/components/ui/button';
+import { useI18n } from '@/utils/chromeI18n';
+import { DataExporter } from '@/utils/dataExporter';
+import type { GenerateResult } from '@/types/testDataGenerator';
+
+interface ExportPanelProps {
+  result: GenerateResult | null;
+}
+
+export default function ExportPanel({ result }: ExportPanelProps) {
+  const { t } = useI18n('testDataGenerator');
+
+  if (!result?.data || result.data.length === 0) {
+    return null;
+  }
+
+  const handleCopyJSON = async () => {
+    const content = DataExporter.toJSON(result.data!);
+    const success = await DataExporter.copyToClipboard(content);
+    if (success) {
+      toast.success(t('testDataGenerator_copySuccess'));
+    } else {
+      toast.error(t('testDataGenerator_copyFailed'));
+    }
+  };
+
+  const handleCopyCSV = async () => {
+    const content = DataExporter.toCSV(result.data!);
+    const success = await DataExporter.copyToClipboard(content);
+    if (success) {
+      toast.success(t('testDataGenerator_copySuccess'));
+    } else {
+      toast.error(t('testDataGenerator_copyFailed'));
+    }
+  };
+
+  const handleDownloadJSON = () => {
+    const file = DataExporter.toSingleFile(result.data!, 'json', 'test-data');
+    DataExporter.download(file);
+  };
+
+  const handleDownloadCSV = () => {
+    const file = DataExporter.toSingleFile(result.data!, 'csv', 'test-data');
+    DataExporter.download(file);
+  };
+
+  return (
+    <div className="space-y-2">
+      <h4 className="text-sm font-medium text-foreground">{t('testDataGenerator_export')}</h4>
+
+      <div className="grid grid-cols-2 gap-2">
+        <Button variant="outline" size="sm" onClick={handleCopyJSON} className="h-9 gap-1.5">
+          <Copy className="h-4 w-4" />
+          {t('testDataGenerator_copyJSON')}
+        </Button>
+
+        <Button variant="outline" size="sm" onClick={handleCopyCSV} className="h-9 gap-1.5">
+          <Copy className="h-4 w-4" />
+          {t('testDataGenerator_copyCSV')}
+        </Button>
+
+        <Button variant="outline" size="sm" onClick={handleDownloadJSON} className="h-9 gap-1.5">
+          <Download className="h-4 w-4" />
+          {t('testDataGenerator_downloadJSON')}
+        </Button>
+
+        <Button variant="outline" size="sm" onClick={handleDownloadCSV} className="h-9 gap-1.5">
+          <Download className="h-4 w-4" />
+          {t('testDataGenerator_downloadCSV')}
+        </Button>
+      </div>
+    </div>
+  );
+}

src/pages/TestDataGenerator/components/FieldEditor.tsx

@@ -0,0 +1,230 @@
+/**
+ * 字段编辑器组件
+ * 编辑单个字段的详细配置
+ */
+
+import { useState, useCallback } from 'react';
+import { useI18n } from '@/utils/chromeI18n';
+import { Input } from '@/components/ui/input';
+import { Switch } from '@/components/ui/switch';
+import { Badge } from '@/components/ui/badge';
+import { getGeneratorById } from '@/lib/generators';
+import type { FieldConfig } from '@/types/testDataGenerator';
+import GeneratorSelector from './GeneratorSelector';
+import GeneratorConfig from './GeneratorConfig';
+
+interface FieldEditorProps {
+  field: FieldConfig;
+  onChange: (field: FieldConfig) => void;
+  /** 所有字段名列表，用于检测重复 */
+  allFieldNames?: string[];
+}
+
+export default function FieldEditor({ field, onChange, allFieldNames = [] }: FieldEditorProps) {
+  const { t } = useI18n('testDataGenerator');
+  const generator = getGeneratorById(field.generatorId);
+  const [nameError, setNameError] = useState<string | null>(null);
+
+  const validateFieldName = useCallback(
+    (name: string): string | null => {
+      const trimmed = name.trim();
+      if (!trimmed) {
+        return t('testDataGenerator_fieldNameEmpty');
+      }
+      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(trimmed)) {
+        return t('testDataGenerator_fieldNameInvalid');
+      }
+      const isDuplicate = allFieldNames.some(
+        (n, i) => n === trimmed && i !== allFieldNames.indexOf(field.name),
+      );
+      if (isDuplicate) {
+        return t('testDataGenerator_fieldNameDuplicate');
+      }
+      return null;
+    },
+    [allFieldNames, field.name, t],
+  );
+
+  const handleNameChange = (name: string) => {
+    onChange({ ...field, name });
+    // 实时校验
+    const error = validateFieldName(name);
+    setNameError(error);
+  };
+
+  const handleDescriptionChange = (description: string) => {
+    onChange({ ...field, description });
+  };
+
+  const handleRequiredChange = (required: boolean) => {
+    onChange({
+      ...field,
+      required,
+      // 切换为必填时清零，切换为非必填时默认 100%
+      nullRate: required ? 0 : 100,
+    });
+  };
+
+  const handleNullRateChange = (nullRate: number) => {
+    // 限制范围 0-100
+    const clampedRate = Math.max(0, Math.min(100, nullRate));
+    // 空值率为 0 时自动设为必填
+    if (clampedRate === 0) {
+      onChange({ ...field, nullRate: clampedRate, required: true });
+    } else {
+      onChange({ ...field, nullRate: clampedRate, required: false });
+    }
+  };
+
+  const handleUniqueChange = (unique: boolean) => {
+    onChange({ ...field, unique });
+  };
+
+  const handleGeneratorChange = (generatorId: string) => {
+    const generator = getGeneratorById(generatorId);
+    const defaultParams: Record<string, unknown> = {};
+    generator?.params.forEach((p) => {
+      defaultParams[p.key] = p.defaultValue;
+    });
+    onChange({
+      ...field,
+      generatorId,
+      params: defaultParams,
+    });
+  };
+
+  const handleParamsChange = (params: Record<string, unknown>) => {
+    onChange({ ...field, params });
+  };
+
+  const nullRatePresets = [
+    { label: '5%', value: 5 },
+    { label: '20%', value: 20 },
+    { label: '50%', value: 50 },
+    { label: '75%', value: 75 },
+  ];
+
+  return (
+    <div className="space-y-5">
+      {/* 基础配置 */}
+      <div className="space-y-4">
+        <div className="space-y-2">
+          <div className="flex items-center justify-between">
+            <label className="text-sm font-medium text-foreground">
+              {t('testDataGenerator_fieldName')}
+            </label>
+            <span className="text-xs text-muted-foreground">{field.name.length}/20</span>
+          </div>
+          <Input
+            value={field.name}
+            onChange={(e) => handleNameChange(e.target.value)}
+            placeholder={t('testDataGenerator_fieldNamePlaceholder')}
+            maxLength={20}
+            className={`h-9 ${nameError ? 'border-destructive' : ''}`}
+          />
+          {nameError && <p className="text-xs text-destructive mt-1">{nameError}</p>}
+        </div>
+
+        <div className="space-y-2">
+          <div className="flex items-center justify-between">
+            <label className="text-sm font-medium text-foreground">
+              {t('testDataGenerator_fieldDescription')}
+            </label>
+            <span className="text-xs text-muted-foreground">
+              {(field.description || '').length}/50
+            </span>
+          </div>
+          <Input
+            value={field.description || ''}
+            onChange={(e) => handleDescriptionChange(e.target.value)}
+            placeholder={t('testDataGenerator_fieldDescriptionPlaceholder')}
+            maxLength={50}
+            className="h-9"
+          />
+        </div>
+      </div>
+
+      {/* 必填/选填配置 */}
+      <div className="space-y-3">
+        <div className="flex items-center justify-between">
+          <label className="text-sm font-medium text-foreground">
+            {t('testDataGenerator_required')}
+          </label>
+          <Switch checked={field.required} onCheckedChange={handleRequiredChange} />
+        </div>
+
+        {!field.required && (
+          <div className="space-y-2 pl-1">
+            <div className="flex items-center justify-between">
+              <span className="text-sm text-muted-foreground">
+                {t('testDataGenerator_nullRate')}
+              </span>
+              <Badge variant="secondary" className="text-xs">
+                {field.nullRate}%
+              </Badge>
+            </div>
+            <Input
+              type="number"
+              value={field.nullRate}
+              onChange={(e) => {
+                const value = Number(e.target.value);
+                if (value >= 0 && value <= 100) {
+                  handleNullRateChange(value);
+                }
+              }}
+              min={0}
+              max={100}
+              step={5}
+              className="h-9 w-full"
+            />
+            <div className="flex gap-2">
+              {nullRatePresets.map((preset) => (
+                <button
+                  key={preset.value}
+                  onClick={() => handleNullRateChange(preset.value)}
+                  className={`px-3 py-1.5 text-xs rounded-md transition-colors ${
+                    field.nullRate === preset.value
+                      ? 'bg-primary text-primary-foreground'
+                      : 'bg-muted text-muted-foreground hover:bg-muted/80'
+                  }`}
+                >
+                  {preset.label}
+                </button>
+              ))}
+            </div>
+          </div>
+        )}
+      </div>
+
+      {/* 唯一性约束 */}
+      <div className="flex items-center justify-between">
+        <label className="text-sm font-medium text-foreground">
+          {t('testDataGenerator_uniqueConstraint')}
+        </label>
+        <Switch checked={field.unique} onCheckedChange={handleUniqueChange} />
+      </div>
+
+      {/* 生成器选择 */}
+      <div className="space-y-2">
+        <label className="text-sm font-medium text-foreground">
+          {t('testDataGenerator_generator')}
+        </label>
+        <GeneratorSelector selectedId={field.generatorId} onChange={handleGeneratorChange} />
+      </div>
+
+      {/* 生成器参数配置 */}
+      {generator && (
+        <div className="space-y-2">
+          <label className="text-sm font-medium text-foreground">
+            {t('testDataGenerator_generatorParams')}
+          </label>
+          <GeneratorConfig
+            generator={generator}
+            params={field.params}
+            onChange={handleParamsChange}
+          />
+        </div>
+      )}
+    </div>
+  );
+}

src/pages/TestDataGenerator/components/FieldItem.tsx

@@ -0,0 +1,59 @@
+/**
+ * 字段项组件
+ * 展示单个字段的基本信息，适配固定高度卡片
+ */
+
+import { useI18n } from '@/utils/chromeI18n';
+import { getGeneratorById } from '@/lib/generators';
+import { Badge } from '@/components/ui/badge';
+import type { FieldConfig } from '@/types/testDataGenerator';
+
+interface FieldItemProps {
+  field: FieldConfig;
+  onClick: () => void;
+}
+
+export default function FieldItem({ field, onClick }: FieldItemProps) {
+  const { t } = useI18n('testDataGenerator');
+  const generator = getGeneratorById(field.generatorId);
+
+  return (
+    <div
+      className="flex-1 min-w-0 cursor-pointer rounded-md transition-all hover:bg-muted/50"
+      onClick={onClick}
+    >
+      <div
+        className={`h-full ${field.description ? 'flex flex-col justify-center' : 'flex items-center'}`}
+      >
+        {/* 第一行：字段名 + 标签 */}
+        <div className="flex items-center gap-1.5 overflow-hidden">
+          <span className="font-medium text-sm text-foreground truncate shrink-0 max-w-[140px]">
+            {field.name}
+          </span>
+          <Badge variant="secondary" className="text-[10px] shrink-0 px-1 py-0">
+            {generator?.name || field.generatorId}
+          </Badge>
+          {!field.required && (
+            <Badge
+              variant="outline"
+              className="text-[10px] shrink-0 px-1 py-0 text-muted-foreground"
+            >
+              {field.nullRate}%
+            </Badge>
+          )}
+          {field.unique && (
+            <Badge variant="outline" className="text-[10px] shrink-0 px-1 py-0 text-blue-500">
+              {t('testDataGenerator_unique')}
+            </Badge>
+          )}
+        </div>
+        {/* 第二行：描述 */}
+        {field.description && (
+          <p className="text-[11px] text-muted-foreground mt-0.5 truncate leading-tight">
+            {field.description}
+          </p>
+        )}
+      </div>
+    </div>
+  );
+}

src/pages/TestDataGenerator/components/FieldList.tsx

@@ -0,0 +1,466 @@
+/**
+ * 字段列表组件
+ * 展示所有字段配置，支持添加、删除、拖拽排序
+ * 超过 5 条时启用虚拟列表滚动
+ */
+
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { Plus, GripVertical, Trash2, Save } from 'lucide-react';
+import { toast } from 'sonner';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Dialog, DialogContent } from '@/components/ui/dialog';
+import { useI18n } from '@/utils/chromeI18n';
+import * as ruleStorage from '@/utils/ruleStorage';
+import {
+  DndContext,
+  closestCenter,
+  KeyboardSensor,
+  PointerSensor,
+  useSensor,
+  useSensors,
+  type DragEndEvent,
+  type DragStartEvent,
+  DragOverlay,
+} from '@dnd-kit/core';
+import {
+  SortableContext,
+  sortableKeyboardCoordinates,
+  verticalListSortingStrategy,
+  useSortable,
+} from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+import type { FieldConfig, DataRule } from '@/types/testDataGenerator';
+import FieldItem from './FieldItem';
+
+/** 最大字段数量 */
+export const MAX_FIELDS = 40;
+
+/** 虚拟列表配置 */
+const VISIBLE_COUNT = 5;
+const ROW_HEIGHT = 60; // 卡片高度 52 + 间距 8
+const ROW_GAP = 8;
+const OVERSCAN = 2;
+const DRAG_OVERSCAN = 10; // 拖拽时增加的预加载范围
+
+interface FieldListProps {
+  fields: FieldConfig[];
+  onUpdate: (index: number, field: FieldConfig) => void;
+  onRemove: (index: number) => void;
+  onAdd: () => void;
+  onEdit: (index: number) => void;
+  onReorder: (oldIndex: number, newIndex: number) => void;
+  editingRule?: DataRule | null;
+  onRuleSaved?: () => void;
+}
+
+/** 可排序的字段项 */
+function SortableFieldItem({
+  field,
+  onEdit,
+  onRemove,
+}: {
+  field: FieldConfig;
+  onEdit: () => void;
+  onRemove: () => void;
+}) {
+  const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({
+    id: field.id,
+  });
+
+  const style = {
+    transform: CSS.Transform.toString(transform),
+    transition,
+    opacity: isDragging ? 0.5 : 1,
+    zIndex: isDragging ? 10 : 0,
+    height: ROW_HEIGHT - ROW_GAP, // 固定卡片高度 52px，与虚拟模式一致
+  };
+
+  return (
+    <div
+      ref={setNodeRef}
+      style={style}
+      className={`group relative rounded-lg border transition-all ${
+        isDragging
+          ? 'border-primary shadow-lg'
+          : 'border-border hover:border-muted-foreground/30 hover:shadow-sm'
+      }`}
+    >
+      <div className="flex items-center gap-2 h-full px-3 py-2">
+        {/* 拖拽手柄 */}
+        <button
+          className="cursor-grab active:cursor-grabbing p-1 rounded hover:bg-muted/50 touch-none shrink-0"
+          {...attributes}
+          {...listeners}
+        >
+          <GripVertical className="h-4 w-4 text-muted-foreground" />
+        </button>
+
+        <div className="flex-1 min-w-0">
+          <FieldItem field={field} onClick={onEdit} />
+        </div>
+
+        <Button
+          variant="ghost"
+          size="icon"
+          className="h-8 w-8 shrink-0 opacity-0 group-hover:opacity-100 transition-opacity text-destructive hover:text-destructive"
+          onClick={onRemove}
+        >
+          <Trash2 className="h-4 w-4" />
+        </Button>
+      </div>
+    </div>
+  );
+}
+
+export default function FieldList({
+  fields,
+  onUpdate: _onUpdate,
+  onRemove,
+  onAdd,
+  onEdit,
+  onReorder,
+  editingRule,
+  onRuleSaved,
+}: FieldListProps) {
+  const { t } = useI18n('testDataGenerator');
+  const [scrollTop, setScrollTop] = useState(0);
+  const [activeId, setActiveId] = useState<string | null>(null);
+  const containerRef = useRef<HTMLDivElement>(null);
+  const [showSaveDialog, setShowSaveDialog] = useState(false);
+  const [showConfirmOverwrite, setShowConfirmOverwrite] = useState(false);
+  const [ruleName, setRuleName] = useState('');
+  const [ruleDescription, setRuleDescription] = useState('');
+
+  const sensors = useSensors(
+    useSensor(PointerSensor, {
+      activationConstraint: { distance: 5 },
+    }),
+    useSensor(KeyboardSensor, {
+      coordinateGetter: sortableKeyboardCoordinates,
+    }),
+  );
+
+  const handleDragStart = (event: DragStartEvent) => {
+    setActiveId(String(event.active.id));
+  };
+
+  // 拖拽时的滚轮滚动处理
+  useEffect(() => {
+    if (!activeId || !containerRef.current) return;
+
+    const container = containerRef.current;
+
+    const handleWheel = (e: WheelEvent) => {
+      e.preventDefault();
+      e.stopPropagation();
+
+      // 滚动容器
+      const scrollAmount = e.deltaY * 0.5; // 降低滚动速度，更易控制
+      const newScrollTop = Math.max(
+        0,
+        Math.min(
+          container.scrollHeight - container.clientHeight,
+          container.scrollTop + scrollAmount,
+        ),
+      );
+      container.scrollTop = newScrollTop;
+      setScrollTop(newScrollTop);
+    };
+
+    // 在 document 级别监听，使用 capture 阶段以优先处理
+    document.addEventListener('wheel', handleWheel, { capture: true, passive: false });
+
+    return () => {
+      document.removeEventListener('wheel', handleWheel, { capture: true });
+    };
+  }, [activeId]);
+
+  const handleDragEnd = (event: DragEndEvent) => {
+    const { active, over } = event;
+    setActiveId(null);
+    if (!over || active.id === over.id) return;
+
+    const oldIndex = fields.findIndex((f) => f.id === active.id);
+    const newIndex = fields.findIndex((f) => f.id === over.id);
+    if (oldIndex !== -1 && newIndex !== -1) {
+      onReorder(oldIndex, newIndex);
+    }
+  };
+
+  const handleScroll = useCallback(() => {
+    if (containerRef.current) {
+      setScrollTop(containerRef.current.scrollTop);
+    }
+  }, []);
+
+  const isVirtual = fields.length > VISIBLE_COUNT;
+  const totalHeight = fields.length * ROW_HEIGHT;
+  const fixedContainerHeight = VISIBLE_COUNT * ROW_HEIGHT;
+  // 少于 5 条时高度自适应，5 条及以上固定为 5 条的高度
+  const containerStyle =
+    fields.length < VISIBLE_COUNT
+      ? { height: 'auto' as const, overflowY: 'visible' as const }
+      : { height: fixedContainerHeight, overflowY: 'auto' as const };
+
+  // 虚拟列表：计算可见范围（拖拽时扩展预加载范围）
+  const currentOverscan = activeId ? DRAG_OVERSCAN : OVERSCAN;
+  const visibleStart = Math.max(0, Math.floor(scrollTop / ROW_HEIGHT) - currentOverscan);
+  const visibleEnd = Math.min(
+    fields.length,
+    Math.ceil((scrollTop + fixedContainerHeight) / ROW_HEIGHT) + currentOverscan,
+  );
+  const visibleFields = isVirtual ? fields.slice(visibleStart, visibleEnd) : fields;
+
+  // 查找拖拽中的项目（用于 DragOverlay）
+  const activeField = activeId ? fields.find((f) => f.id === activeId) : null;
+
+  const isMaxReached = fields.length >= MAX_FIELDS;
+
+  // 编辑模式下，保存时更新原规则
+  const handleUpdateRule = useCallback(() => {
+    if (!editingRule) return;
+
+    const updated = ruleStorage.update(editingRule.id, {
+      fields: fields,
+    });
+
+    if (updated) {
+      toast.success(t('testDataGenerator_ruleUpdated'));
+      onRuleSaved?.();
+    }
+  }, [editingRule, fields, t, onRuleSaved]);
+
+  // 新建规则或另存为
+  const handleSave = useCallback(
+    (overwrite = false) => {
+      if (!ruleName.trim()) return;
+
+      const trimmedName = ruleName.trim();
+
+      // 检查名称是否重复
+      if (!overwrite) {
+        const existingRule = ruleStorage.getByName(trimmedName);
+        if (existingRule) {
+          setShowConfirmOverwrite(true);
+          return;
+        }
+      }
+
+      const newRule = ruleStorage.save({
+        name: trimmedName,
+        description: ruleDescription.trim(),
+        fields: fields,
+      });
+
+      if (newRule) {
+        setShowSaveDialog(false);
+        setShowConfirmOverwrite(false);
+        setRuleName('');
+        setRuleDescription('');
+        toast.success(t('testDataGenerator_ruleSaved'));
+        onRuleSaved?.();
+      }
+    },
+    [ruleName, ruleDescription, fields, t, onRuleSaved],
+  );
+
+  return (
+    <div className="flex flex-col h-full">
+      <div className="flex items-center justify-between mb-3">
+        <h3 className="text-sm font-medium text-foreground">
+          {t('testDataGenerator_fields')} ({fields.length}/{MAX_FIELDS})
+        </h3>
+        <div className="flex items-center gap-2">
+          {editingRule ? (
+            <>
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={handleUpdateRule}
+                disabled={fields.length === 0}
+                className="h-8 gap-1.5 px-2.5"
+                title={`${t('testDataGenerator_editing')}: ${editingRule.name}`}
+              >
+                <Save className="h-3.5 w-3.5" />
+                {t('testDataGenerator_updateRule')}
+              </Button>
+              <Button
+                variant="ghost"
+                size="sm"
+                onClick={() => setShowSaveDialog(true)}
+                disabled={fields.length === 0}
+                className="h-8 px-2"
+              >
+                {t('testDataGenerator_saveAs')}
+              </Button>
+            </>
+          ) : (
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => setShowSaveDialog(true)}
+              disabled={fields.length === 0}
+              className="h-8 gap-1.5 px-2.5"
+            >
+              <Save className="h-3.5 w-3.5" />
+              {t('testDataGenerator_saveRule')}
+            </Button>
+          )}
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={onAdd}
+            disabled={isMaxReached}
+            className="h-8 gap-1.5 px-2.5"
+          >
+            <Plus className="h-4 w-4" />
+            {t('testDataGenerator_addField')}
+          </Button>
+        </div>
+      </div>
+
+      <div className="flex-1 min-h-0">
+        {fields.length === 0 ? (
+          <div className="flex flex-col items-center justify-center py-8 text-center">
+            <GripVertical className="h-10 w-10 text-muted-foreground/40 mb-3" />
+            <p className="text-sm text-muted-foreground">{t('testDataGenerator_noFields')}</p>
+            <p className="text-xs text-muted-foreground/70 mt-1">
+              {t('testDataGenerator_addFieldHint')}
+            </p>
+          </div>
+        ) : (
+          <DndContext
+            sensors={sensors}
+            collisionDetection={closestCenter}
+            onDragStart={handleDragStart}
+            onDragEnd={handleDragEnd}
+          >
+            <SortableContext items={fields.map((f) => f.id)} strategy={verticalListSortingStrategy}>
+              <div
+                ref={containerRef}
+                className="overflow-y-auto"
+                style={containerStyle}
+                onScroll={handleScroll}
+              >
+                {isVirtual ? (
+                  /* 虚拟滚动模式 */
+                  <div style={{ height: totalHeight, position: 'relative' }}>
+                    <div
+                      style={{
+                        position: 'absolute',
+                        top: visibleStart * ROW_HEIGHT,
+                        left: 0,
+                        right: 0,
+                      }}
+                    >
+                      {visibleFields.map((field, vi) => {
+                        const realIndex = fields.findIndex((f) => f.id === field.id);
+                        const isLast = visibleStart + vi === fields.length - 1;
+                        return (
+                          <div
+                            key={field.id}
+                            style={{
+                              height: ROW_HEIGHT,
+                              paddingBottom: isLast ? 0 : ROW_GAP,
+                            }}
+                          >
+                            <SortableFieldItem
+                              field={field}
+                              onEdit={() => onEdit(realIndex)}
+                              onRemove={() => onRemove(realIndex)}
+                            />
+                          </div>
+                        );
+                      })}
+                    </div>
+                  </div>
+                ) : (
+                  /* 普通模式（≤5 条） */
+                  <div className="space-y-2">
+                    {fields.map((field, index) => (
+                      <SortableFieldItem
+                        key={field.id}
+                        field={field}
+                        onEdit={() => onEdit(index)}
+                        onRemove={() => onRemove(index)}
+                      />
+                    ))}
+                  </div>
+                )}
+              </div>
+            </SortableContext>
+            <DragOverlay>
+              {activeField ? (
+                <div className="rounded-lg border border-primary bg-background shadow-lg opacity-90">
+                  <div className="flex items-center gap-2 h-full px-3 py-2">
+                    <div className="p-1">
+                      <GripVertical className="h-4 w-4 text-muted-foreground" />
+                    </div>
+                    <div className="flex-1 min-w-0">
+                      <FieldItem field={activeField} onClick={() => {}} />
+                    </div>
+                    <div className="h-8 w-8 shrink-0" />
+                  </div>
+                </div>
+              ) : null}
+            </DragOverlay>
+          </DndContext>
+        )}
+      </div>
+
+      {/* 保存规则对话框 */}
+      <Dialog open={showSaveDialog} onOpenChange={setShowSaveDialog}>
+        <DialogContent
+          showCloseButton={false}
+          className="w-[calc(100vw-4rem)] max-w-[420px] p-0 pt-6 flex flex-col"
+        >
+          <div className="flex-1 overflow-y-auto px-6 pt-2 pb-4 space-y-4">
+            <Input
+              value={ruleName}
+              onChange={(e) => setRuleName(e.target.value)}
+              placeholder={t('testDataGenerator_ruleNamePlaceholder')}
+              className="h-9"
+            />
+            <Input
+              value={ruleDescription}
+              onChange={(e) => setRuleDescription(e.target.value)}
+              placeholder={t('testDataGenerator_ruleDescPlaceholder')}
+              className="h-9"
+            />
+          </div>
+          <div className="flex justify-end gap-2 px-6 py-2 border-t shrink-0">
+            <Button variant="ghost" size="sm" onClick={() => setShowSaveDialog(false)}>
+              {t('testDataGenerator_cancel')}
+            </Button>
+            <Button size="sm" onClick={() => handleSave()} disabled={!ruleName.trim()}>
+              {t('testDataGenerator_confirm')}
+            </Button>
+          </div>
+        </DialogContent>
+      </Dialog>
+
+      {/* 覆盖确认对话框 */}
+      <Dialog open={showConfirmOverwrite} onOpenChange={setShowConfirmOverwrite}>
+        <DialogContent
+          showCloseButton={false}
+          className="w-[calc(100vw-4rem)] max-w-[420px] p-0 pt-6 flex flex-col"
+        >
+          <div className="flex-1 overflow-y-auto px-6 pb-4">
+            <p className="text-sm text-muted-foreground">
+              {t('testDataGenerator_ruleNameDuplicate')}
+            </p>
+          </div>
+          <div className="flex justify-end gap-2 px-6 py-2 border-t shrink-0">
+            <Button variant="ghost" size="sm" onClick={() => setShowConfirmOverwrite(false)}>
+              {t('testDataGenerator_cancel')}
+            </Button>
+            <Button size="sm" onClick={() => handleSave(true)}>
+              {t('testDataGenerator_overwrite')}
+            </Button>
+          </div>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}

src/pages/TestDataGenerator/components/GenerateButton.tsx

@@ -0,0 +1,73 @@
+/**
+ * 生成按钮组件
+ * 显示生成按钮、加载状态和进度条
+ */
+
+import { Play, Square } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { useI18n } from '@/utils/chromeI18n';
+import type { GenerateProgress } from '@/types/testDataGenerator';
+
+interface GenerateButtonProps {
+  onClick: () => void;
+  onCancel: () => void;
+  isGenerating: boolean;
+  progress: GenerateProgress | null;
+  disabled?: boolean;
+}
+
+export default function GenerateButton({
+  onClick,
+  onCancel,
+  isGenerating,
+  progress,
+  disabled,
+}: GenerateButtonProps) {
+  const { t } = useI18n('testDataGenerator');
+
+  return (
+    <div className="space-y-3">
+      {isGenerating ? (
+        <>
+          <Button variant="destructive" onClick={onCancel} className="w-full h-11 gap-2">
+            <Square className="h-5 w-5" />
+            {t('testDataGenerator_cancel')}
+          </Button>
+
+          {/* 进度条 */}
+          {progress && (
+            <div className="space-y-2">
+              <div className="flex items-center justify-between text-xs text-muted-foreground">
+                <span>
+                  {t('testDataGenerator_progress', {
+                    current: progress.generated.toLocaleString(),
+                    total: progress.total.toLocaleString(),
+                  })}
+                </span>
+                <span>{progress.progress}%</span>
+              </div>
+              <div className="h-2 bg-muted rounded-full overflow-hidden">
+                <div
+                  className="h-full bg-primary transition-all duration-300"
+                  style={{ width: `${progress.progress}%` }}
+                />
+              </div>
+              {progress.estimatedTimeLeft !== undefined && (
+                <p className="text-xs text-muted-foreground text-center">
+                  {t('testDataGenerator_estimatedTime', {
+                    time: Math.ceil(progress.estimatedTimeLeft / 1000),
+                  })}
+                </p>
+              )}
+            </div>
+          )}
+        </>
+      ) : (
+        <Button onClick={onClick} disabled={disabled} className="w-full h-11 gap-2">
+          <Play className="h-5 w-5" />
+          {t('testDataGenerator_generate')}
+        </Button>
+      )}
+    </div>
+  );
+}

src/pages/TestDataGenerator/components/GenerateOptions.tsx

@@ -0,0 +1,91 @@
+/**
+ * 生成选项组件
+ * 配置生成数量、数据格式等选项
+ */
+
+import { useI18n } from '@/utils/chromeI18n';
+import { Input } from '@/components/ui/input';
+
+interface GenerateOptionsProps {
+  count: number;
+  onCountChange: (count: number) => void;
+  format: 'json' | 'csv';
+  onFormatChange: (format: 'json' | 'csv') => void;
+}
+
+const COUNT_PRESETS = [50, 100, 1000, 5000, 10000];
+
+const FORMAT_OPTIONS = [
+  { value: 'json' as const, label: 'JSON' },
+  { value: 'csv' as const, label: 'CSV' },
+];
+
+export default function GenerateOptions({
+  count,
+  onCountChange,
+  format,
+  onFormatChange,
+}: GenerateOptionsProps) {
+  const { t } = useI18n('testDataGenerator');
+
+  return (
+    <div className="space-y-4">
+      {/* 生成数量 */}
+      <div className="space-y-2">
+        <label className="text-sm font-medium text-foreground">
+          {t('testDataGenerator_count')}
+        </label>
+        <div className="flex flex-wrap gap-2">
+          {COUNT_PRESETS.map((preset) => (
+            <button
+              key={preset}
+              onClick={() => onCountChange(preset)}
+              className={`px-3 py-1.5 text-xs font-medium rounded-md transition-colors ${
+                count === preset
+                  ? 'bg-primary text-primary-foreground'
+                  : 'bg-muted text-muted-foreground hover:bg-muted/80'
+              }`}
+            >
+              {preset.toLocaleString()}
+            </button>
+          ))}
+        </div>
+        <Input
+          type="number"
+          value={count}
+          onChange={(e) => {
+            const value = Number(e.target.value);
+            if (value > 0 && value <= 100000) {
+              onCountChange(value);
+            }
+          }}
+          min={1}
+          max={100000}
+          className="h-9"
+        />
+      </div>
+
+      {/* 数据格式 */}
+      <div className="space-y-2">
+        <label className="text-sm font-medium text-foreground">
+          {t('testDataGenerator_format')}
+        </label>
+        <div className="flex gap-2">
+          {FORMAT_OPTIONS.map((option) => (
+            <button
+              key={option.value}
+              onClick={() => onFormatChange(option.value)}
+              className={`flex-1 px-3 py-1.5 text-xs font-medium rounded-md transition-colors ${
+                format === option.value
+                  ? 'bg-primary text-primary-foreground'
+                  : 'bg-muted text-muted-foreground hover:bg-muted/80'
+              }`}
+            >
+              {option.label}
+            </button>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}

src/pages/TestDataGenerator/components/GeneratorConfig.tsx

@@ -0,0 +1,126 @@
+/**
+ * 生成器配置组件
+ * 根据生成器参数定义动态渲染配置表单
+ */
+
+import { Input } from '@/components/ui/input';
+import { Switch } from '@/components/ui/switch';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import { useI18n } from '@/utils/chromeI18n';
+import type { GeneratorDefinition } from '@/types/testDataGenerator';
+
+interface GeneratorConfigProps {
+  generator: GeneratorDefinition;
+  params: Record<string, unknown>;
+  onChange: (params: Record<string, unknown>) => void;
+}
+
+export default function GeneratorConfig({ generator, params, onChange }: GeneratorConfigProps) {
+  const { t } = useI18n('testDataGenerator');
+  const handleParamChange = (key: string, value: unknown) => {
+    onChange({ ...params, [key]: value });
+  };
+
+  if (generator.params.length === 0) {
+    return (
+      <p className="text-sm text-muted-foreground py-2">
+        {t('testDataGenerator_noGeneratorParams')}
+      </p>
+    );
+  }
+
+  return (
+    <div className="space-y-4 p-3 rounded-lg bg-muted/30">
+      {generator.params.map((param) => (
+        <div key={param.key} className="space-y-2">
+          <label className="text-sm font-medium text-foreground">
+            {param.label}
+            {param.required && <span className="text-destructive ml-1">*</span>}
+          </label>
+          {param.description && (
+            <p className="text-xs text-muted-foreground">{param.description}</p>
+          )}
+
+          {param.type === 'string' && (
+            <Input
+              value={String(params[param.key] ?? param.defaultValue)}
+              onChange={(e) => handleParamChange(param.key, e.target.value)}
+              placeholder={param.placeholder}
+              className="h-9"
+            />
+          )}
+
+          {param.type === 'number' && (
+            <Input
+              type="number"
+              value={Number(params[param.key] ?? param.defaultValue)}
+              onChange={(e) => handleParamChange(param.key, Number(e.target.value))}
+              min={param.min}
+              max={param.max}
+              className="h-9"
+            />
+          )}
+
+          {param.type === 'boolean' && (
+            <div className="flex items-center justify-between">
+              <span className="text-sm text-muted-foreground">
+                {params[param.key] !== false
+                  ? t('testDataGenerator_enabled')
+                  : t('testDataGenerator_disabled')}
+              </span>
+              <Switch
+                checked={params[param.key] !== false}
+                onCheckedChange={(checked) => handleParamChange(param.key, checked)}
+              />
+            </div>
+          )}
+
+          {param.type === 'select' && (
+            <Select
+              value={String(params[param.key] ?? param.defaultValue)}
+              onValueChange={(value) => handleParamChange(param.key, value)}
+            >
+              <SelectTrigger className="h-9">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {param.options?.map((option) => (
+                  <SelectItem key={String(option.value)} value={String(option.value)}>
+                    {option.label}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          )}
+
+          {param.type === 'array' && (
+            <Input
+              value={
+                Array.isArray(params[param.key])
+                  ? (params[param.key] as string[]).join(', ')
+                  : String(param.defaultValue || '')
+              }
+              onChange={(e) =>
+                handleParamChange(
+                  param.key,
+                  e.target.value
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean),
+                )
+              }
+              placeholder={t('testDataGenerator_commaSeparated')}
+              className="h-9"
+            />
+          )}
+        </div>
+      ))}
+    </div>
+  );
+}

src/pages/TestDataGenerator/components/GeneratorSelector.tsx

@@ -0,0 +1,90 @@
+/**
+ * 生成器选择器组件
+ * 以分类形式展示所有可用生成器
+ */
+
+import { useState } from 'react';
+import { Search, User, Briefcase, Code, Hash } from 'lucide-react';
+import { Input } from '@/components/ui/input';
+import { useI18n } from '@/utils/chromeI18n';
+import { generatorCategories, getGeneratorsByCategory, searchGenerators } from '@/lib/generators';
+
+interface GeneratorSelectorProps {
+  selectedId: string;
+  onChange: (id: string) => void;
+}
+
+const categoryIcons: Record<string, React.ComponentType<{ className?: string }>> = {
+  personal: User,
+  business: Briefcase,
+  technical: Code,
+  basic: Hash,
+};
+
+export default function GeneratorSelector({ selectedId, onChange }: GeneratorSelectorProps) {
+  const { t } = useI18n('testDataGenerator');
+  const [searchQuery, setSearchQuery] = useState('');
+  const [activeCategory, setActiveCategory] = useState<string>(generatorCategories[0]?.id || '');
+
+  const generators = searchQuery
+    ? searchGenerators(searchQuery)
+    : getGeneratorsByCategory(activeCategory);
+
+  return (
+    <div className="space-y-3">
+      {/* 搜索框 */}
+      <div className="relative">
+        <Search className="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" />
+        <Input
+          value={searchQuery}
+          onChange={(e) => setSearchQuery(e.target.value)}
+          placeholder={t('testDataGenerator_searchGenerator')}
+          className="pl-9 h-9"
+        />
+      </div>
+
+      {/* 分类标签 */}
+      {!searchQuery && (
+        <div className="flex flex-wrap gap-2">
+          {generatorCategories.map((category) => {
+            const Icon = categoryIcons[category.id];
+            return (
+              <button
+                key={category.id}
+                onClick={() => setActiveCategory(category.id)}
+                className={`flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-md transition-colors ${
+                  activeCategory === category.id
+                    ? 'bg-primary text-primary-foreground'
+                    : 'bg-muted text-muted-foreground hover:bg-muted/80'
+                }`}
+              >
+                {Icon && <Icon className="h-3.5 w-3.5" />}
+                {category.name}
+              </button>
+            );
+          })}
+        </div>
+      )}
+
+      {/* 生成器列表 */}
+      <div className="grid grid-cols-2 gap-2 max-h-48 overflow-y-auto">
+        {generators.map((generator) => (
+          <button
+            key={generator.id}
+            onClick={() => onChange(generator.id)}
+            className={`flex flex-col items-start p-2 text-left rounded-md border transition-colors ${
+              selectedId === generator.id
+                ? 'border-primary bg-primary/5'
+                : 'border-border hover:border-muted-foreground/30'
+            }`}
+          >
+            <span className="text-sm font-medium text-foreground">{generator.name}</span>
+            <span className="text-xs text-muted-foreground line-clamp-1">
+              {generator.description}
+            </span>
+          </button>
+        ))}
+      </div>
+    </div>
+  );
+}

src/pages/TestDataGenerator/components/ResultPanel.tsx

@@ -0,0 +1,115 @@
+/**
+ * 结果面板组件
+ * 展示生成结果的状态和统计信息
+ */
+
+import { CheckCircle, AlertTriangle, XCircle, Clock, Database } from 'lucide-react';
+import { useI18n } from '@/utils/chromeI18n';
+import type { GenerateResult } from '@/types/testDataGenerator';
+
+interface ResultPanelProps {
+  result: GenerateResult | null;
+}
+
+export default function ResultPanel({ result }: ResultPanelProps) {
+  const { t } = useI18n('testDataGenerator');
+
+  if (!result) return null;
+
+  const getStatusIcon = () => {
+    if (result.success && (!result.warnings || result.warnings.length === 0)) {
+      return <CheckCircle className="h-5 w-5 text-green-500" />;
+    }
+    if (result.success && result.warnings && result.warnings.length > 0) {
+      return <AlertTriangle className="h-5 w-5 text-yellow-500" />;
+    }
+    return <XCircle className="h-5 w-5 text-destructive" />;
+  };
+
+  const getStatusText = () => {
+    if (result.success && (!result.warnings || result.warnings.length === 0)) {
+      return t('testDataGenerator_success');
+    }
+    if (result.success && result.warnings && result.warnings.length > 0) {
+      return t('testDataGenerator_partialSuccess');
+    }
+    return t('testDataGenerator_failed');
+  };
+
+  return (
+    <div className="space-y-3">
+      {/* 状态标题 */}
+      <div className="flex items-center gap-2">
+        {getStatusIcon()}
+        <span className="text-sm font-medium text-foreground">{getStatusText()}</span>
+      </div>
+
+      {/* 统计信息 */}
+      {result.stats && (
+        <div className="grid grid-cols-3 gap-3">
+          <div className="flex flex-col items-center p-2 rounded-lg bg-muted/30">
+            <Database className="h-4 w-4 text-muted-foreground mb-1" />
+            <span className="text-lg font-semibold text-foreground">
+              {result.stats.total.toLocaleString()}
+            </span>
+            <span className="text-xs text-muted-foreground">
+              {t('testDataGenerator_totalCount')}
+            </span>
+          </div>
+
+          <div className="flex flex-col items-center p-2 rounded-lg bg-muted/30">
+            <CheckCircle className="h-4 w-4 text-green-500 mb-1" />
+            <span className="text-lg font-semibold text-green-500">
+              {result.stats.success.toLocaleString()}
+            </span>
+            <span className="text-xs text-muted-foreground">
+              {t('testDataGenerator_successCount')}
+            </span>
+          </div>
+
+          <div className="flex flex-col items-center p-2 rounded-lg bg-muted/30">
+            <Clock className="h-4 w-4 text-muted-foreground mb-1" />
+            <span className="text-lg font-semibold text-foreground">
+              {(result.stats.duration / 1000).toFixed(2)}s
+            </span>
+            <span className="text-xs text-muted-foreground">{t('testDataGenerator_duration')}</span>
+          </div>
+        </div>
+      )}
+
+      {/* 警告信息 */}
+      {result.warnings && result.warnings.length > 0 && (
+        <div className="p-3 rounded-lg bg-yellow-500/10 border border-yellow-500/20">
+          <div className="flex items-center gap-2 mb-2">
+            <AlertTriangle className="h-4 w-4 text-yellow-500" />
+            <span className="text-sm font-medium text-yellow-500">
+              {t('testDataGenerator_warnings')}
+            </span>
+          </div>
+          <ul className="list-disc list-inside space-y-1">
+            {result.warnings.slice(0, 5).map((warning, index) => (
+              <li key={index} className="text-xs text-yellow-500/80">
+                {warning}
+              </li>
+            ))}
+            {result.warnings.length > 5 && (
+              <li className="text-xs text-yellow-500/80">
+                ... {t('testDataGenerator_moreWarnings', { count: result.warnings.length - 5 })}
+              </li>
+            )}
+          </ul>
+        </div>
+      )}
+
+      {/* 错误信息 */}
+      {result.error && (
+        <div className="p-3 rounded-lg bg-destructive/10 border border-destructive/20">
+          <div className="flex items-center gap-2">
+            <XCircle className="h-4 w-4 text-destructive" />
+            <span className="text-sm text-destructive">{result.error}</span>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

src/pages/TestDataGenerator/components/RuleManager.tsx

@@ -0,0 +1,324 @@
+/**
+ * 规则管理器组件
+ * 管理测试数据生成规则的加载、删除等操作
+ */
+
+import { useState, useEffect, useCallback, useMemo } from 'react';
+import {
+  Search,
+  Upload,
+  Download,
+  Trash2,
+  Copy,
+  Edit,
+  Clock,
+  Tag,
+  Loader2,
+  FolderOpen,
+} from 'lucide-react';
+import { toast } from 'sonner';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Dialog, DialogContent } from '@/components/ui/dialog';
+import { useI18n } from '@/utils/chromeI18n';
+import * as ruleStorage from '@/utils/ruleStorage';
+import type { DataRule, FieldConfig } from '@/types/testDataGenerator';
+
+interface RuleManagerProps {
+  onLoad: (fields: FieldConfig[]) => void;
+  onEdit?: (rule: DataRule) => void;
+  onRulesChanged?: () => void;
+}
+
+export default function RuleManager({ onLoad, onEdit, onRulesChanged }: RuleManagerProps) {
+  const { t, i18n } = useI18n('testDataGenerator');
+  const [rules, setRules] = useState<DataRule[]>(() => ruleStorage.getAll());
+  const [searchQuery, setSearchQuery] = useState('');
+  const [debouncedSearchQuery, setDebouncedSearchQuery] = useState('');
+  const [ruleToDelete, setRuleToDelete] = useState<DataRule | null>(null);
+  const [isImporting, setIsImporting] = useState(false);
+  const [isExporting, setIsExporting] = useState(false);
+
+  const loadRules = useCallback(() => {
+    setRules(ruleStorage.getAll());
+  }, []);
+
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedSearchQuery(searchQuery);
+    }, 250);
+    return () => clearTimeout(timer);
+  }, [searchQuery]);
+
+  const filteredRules = useMemo(() => {
+    if (!debouncedSearchQuery) return rules;
+    const query = debouncedSearchQuery.toLowerCase();
+    return rules.filter(
+      (rule) =>
+        rule.name.toLowerCase().includes(query) || rule.description?.toLowerCase().includes(query),
+    );
+  }, [rules, debouncedSearchQuery]);
+
+  const handleLoad = useCallback(
+    (rule: DataRule) => {
+      onLoad(rule.fields);
+      ruleStorage.recordUse(rule.id);
+      loadRules();
+      toast.success(t('testDataGenerator_ruleLoaded', { name: rule.name }));
+    },
+    [onLoad, loadRules, t],
+  );
+
+  const handleDelete = useCallback(() => {
+    if (!ruleToDelete) return;
+    ruleStorage.deleteRule(ruleToDelete.id);
+    loadRules();
+    setRuleToDelete(null);
+    toast.success(t('testDataGenerator_ruleDeleted'));
+    onRulesChanged?.();
+  }, [ruleToDelete, loadRules, t, onRulesChanged]);
+
+  const handleDuplicate = useCallback(
+    (id: string) => {
+      const result = ruleStorage.duplicate(id, t('testDataGenerator_ruleCopySuffix'));
+      if (result) {
+        loadRules();
+        toast.success(t('testDataGenerator_ruleDuplicated'));
+        onRulesChanged?.();
+      }
+    },
+    [loadRules, t, onRulesChanged],
+  );
+
+  const handleEdit = useCallback(
+    (rule: DataRule) => {
+      onEdit?.(rule);
+    },
+    [onEdit],
+  );
+
+  const handleExport = useCallback(() => {
+    try {
+      setIsExporting(true);
+      const json = ruleStorage.exportRules();
+      const blob = new Blob([json], { type: 'application/json' });
+      const url = URL.createObjectURL(blob);
+      try {
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = 'test-data-rules.json';
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+      } finally {
+        URL.revokeObjectURL(url);
+      }
+      toast.success(t('testDataGenerator_exportSuccess'));
+    } catch (error) {
+      console.error('[RuleManager] 导出失败:', error);
+      toast.error(t('testDataGenerator_exportFailed'));
+    } finally {
+      setIsExporting(false);
+    }
+  }, [t]);
+
+  const handleImport = useCallback(() => {
+    const input = document.createElement('input');
+    input.type = 'file';
+    input.accept = '.json';
+    input.onchange = async (e) => {
+      try {
+        setIsImporting(true);
+        const file = (e.target as HTMLInputElement).files?.[0];
+        if (!file) return;
+
+        const text = await file.text();
+        const result = ruleStorage.importRules(text);
+
+        if (result.success > 0) {
+          toast.success(t('testDataGenerator_importSuccess', { count: result.success }));
+        }
+
+        if (result.failed > 0) {
+          toast.error(t('testDataGenerator_importFailed', { count: result.failed }));
+          console.warn('[RuleManager] 导入警告:', result.errors);
+        }
+
+        loadRules();
+        onRulesChanged?.();
+      } catch (error) {
+        console.error('[RuleManager] 导入失败:', error);
+        toast.error(t('testDataGenerator_importFailed'));
+      } finally {
+        setIsImporting(false);
+      }
+    };
+    input.click();
+  }, [loadRules, t, onRulesChanged]);
+
+  const formatDate = useCallback(
+    (timestamp: number) => {
+      return new Date(timestamp).toLocaleDateString(i18n.language || 'zh-CN', {
+        month: 'short',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+      });
+    },
+    [i18n.language],
+  );
+
+  return (
+    <div className="space-y-4">
+      {/* 删除确认对话框 */}
+      <Dialog open={!!ruleToDelete} onOpenChange={() => setRuleToDelete(null)}>
+        <DialogContent
+          showCloseButton={false}
+          className="w-[calc(100vw-4rem)] max-w-[420px] p-0 pt-6 flex flex-col"
+        >
+          <div className="flex-1 overflow-y-auto px-6 pb-4">
+            <p className="text-sm text-muted-foreground">
+              {t('testDataGenerator_confirmDeleteDescription', { name: ruleToDelete?.name ?? '' })}
+            </p>
+          </div>
+          <div className="flex justify-end gap-2 px-6 py-2 border-t shrink-0">
+            <Button variant="ghost" size="sm" onClick={() => setRuleToDelete(null)}>
+              {t('testDataGenerator_cancel')}
+            </Button>
+            <Button variant="destructive" size="sm" onClick={handleDelete}>
+              {t('testDataGenerator_confirm')}
+            </Button>
+          </div>
+        </DialogContent>
+      </Dialog>
+
+      {/* 工具栏 */}
+      <div className="flex items-center gap-2 flex-wrap">
+        <Button
+          variant="outline"
+          size="sm"
+          onClick={handleImport}
+          disabled={isImporting}
+          className="h-8 gap-1.5"
+        >
+          {isImporting ? (
+            <Loader2 className="h-4 w-4 animate-spin" />
+          ) : (
+            <Upload className="h-4 w-4" />
+          )}
+          {t('testDataGenerator_import')}
+        </Button>
+        <Button
+          variant="outline"
+          size="sm"
+          onClick={handleExport}
+          disabled={isExporting || rules.length === 0}
+          className="h-8 gap-1.5"
+        >
+          {isExporting ? (
+            <Loader2 className="h-4 w-4 animate-spin" />
+          ) : (
+            <Download className="h-4 w-4" />
+          )}
+          {t('testDataGenerator_export')}
+        </Button>
+      </div>
+
+      {/* 搜索框 */}
+      <div className="relative">
+        <Search className="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" />
+        <Input
+          value={searchQuery}
+          onChange={(e) => setSearchQuery(e.target.value.slice(0, 20))}
+          placeholder={t('testDataGenerator_searchRules')}
+          className="pl-9 pr-24 h-9"
+          maxLength={20}
+        />
+        <span className="absolute right-3 top-1/2 -translate-y-1/2 text-xs text-muted-foreground pointer-events-none">
+          {t('testDataGenerator_ruleCount', { count: rules.length, max: 20 })}
+        </span>
+      </div>
+
+      {/* 规则列表 */}
+      <div className="space-y-2 max-h-64 overflow-y-auto">
+        {filteredRules.length === 0 ? (
+          <div className="text-center py-6">
+            <Tag className="h-8 w-8 text-muted-foreground/40 mx-auto mb-2" />
+            <p className="text-sm text-muted-foreground">
+              {debouncedSearchQuery
+                ? t('testDataGenerator_noSearchResults')
+                : t('testDataGenerator_noRules')}
+            </p>
+          </div>
+        ) : (
+          filteredRules.map((rule) => (
+            <div
+              key={rule.id}
+              className="flex items-center gap-3 p-2 rounded-lg border hover:bg-muted/30 transition-colors"
+            >
+              <div className="flex-1 min-w-0">
+                <div className="flex items-center gap-2">
+                  <span className="font-medium text-sm text-foreground truncate">{rule.name}</span>
+                  <span className="text-xs text-muted-foreground">
+                    {rule.fields.length} {t('testDataGenerator_fields')}
+                  </span>
+                </div>
+                {rule.description && (
+                  <p className="text-xs text-muted-foreground truncate mt-0.5">
+                    {rule.description}
+                  </p>
+                )}
+                <div className="flex items-center gap-3 mt-1 text-xs text-muted-foreground">
+                  <span className="flex items-center gap-1">
+                    <Clock className="h-3 w-3" />
+                    {formatDate(rule.updatedAt)}
+                  </span>
+                  <span>{t('testDataGenerator_usedTimes', { count: rule.useCount })}</span>
+                </div>
+              </div>
+
+              <div className="flex items-center gap-1">
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="h-7 w-7"
+                  onClick={() => handleLoad(rule)}
+                  title={t('testDataGenerator_load')}
+                >
+                  <FolderOpen className="h-3.5 w-3.5" />
+                </Button>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="h-7 w-7"
+                  onClick={() => handleEdit(rule)}
+                  title={t('testDataGenerator_edit')}
+                >
+                  <Edit className="h-3.5 w-3.5" />
+                </Button>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="h-7 w-7"
+                  onClick={() => handleDuplicate(rule.id)}
+                  title={t('testDataGenerator_duplicate')}
+                >
+                  <Copy className="h-3.5 w-3.5" />
+                </Button>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="h-7 w-7 text-destructive hover:text-destructive"
+                  onClick={() => setRuleToDelete(rule)}
+                  title={t('testDataGenerator_delete')}
+                >
+                  <Trash2 className="h-3.5 w-3.5" />
+                </Button>
+              </div>
+            </div>
+          ))
+        )}
+      </div>
+    </div>
+  );
+}

src/pages/TestDataGenerator/components/__tests__/RuleManager.test.tsx

@@ -0,0 +1,189 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+// Mock dependencies
+vi.mock('@/utils/ruleStorage', () => ({
+  getAll: vi.fn(() => []),
+  save: vi.fn(),
+  deleteRule: vi.fn(),
+  duplicate: vi.fn(),
+  recordUse: vi.fn(),
+  search: vi.fn(() => []),
+  exportRules: vi.fn(() => '[]'),
+  importRules: vi.fn(() => ({ success: 0, failed: 0, errors: [] })),
+}));
+
+vi.mock('sonner', () => ({
+  toast: {
+    success: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+import RuleManager from '../RuleManager';
+import * as ruleStorage from '@/utils/ruleStorage';
+import { toast } from 'sonner';
+import type { DataRule, FieldConfig } from '@/types/testDataGenerator';
+
+const mockedRuleStorage = vi.mocked(ruleStorage);
+const mockedToast = vi.mocked(toast);
+
+const mockFields: FieldConfig[] = [
+  {
+    id: 'field-1',
+    name: 'name',
+    generatorId: 'string',
+    params: {},
+    required: true,
+    nullRate: 0,
+    unique: false,
+  },
+];
+
+const mockRule: DataRule = {
+  id: 'rule-1',
+  name: 'Test Rule',
+  description: 'Test description',
+  fields: mockFields,
+  createdAt: Date.now(),
+  updatedAt: Date.now(),
+  useCount: 0,
+};
+
+describe('RuleManager', () => {
+  const defaultProps = {
+    onLoad: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockedRuleStorage.getAll.mockReturnValue([]);
+  });
+
+  it('should render empty state when no rules', () => {
+    render(<RuleManager {...defaultProps} />);
+
+    expect(screen.getByText('暂无保存的规则')).toBeInTheDocument();
+  });
+
+  it('should render rule list when rules exist', () => {
+    mockedRuleStorage.getAll.mockReturnValue([mockRule]);
+
+    render(<RuleManager {...defaultProps} />);
+
+    expect(screen.getByText('Test Rule')).toBeInTheDocument();
+    expect(screen.getByText('Test description')).toBeInTheDocument();
+  });
+
+  it('should load rule when load button clicked', async () => {
+    const user = userEvent.setup();
+    mockedRuleStorage.getAll.mockReturnValue([mockRule]);
+
+    render(<RuleManager {...defaultProps} />);
+
+    const loadButton = screen.getByTitle('加载');
+    await user.click(loadButton);
+
+    expect(defaultProps.onLoad).toHaveBeenCalledWith(mockFields);
+    expect(mockedRuleStorage.recordUse).toHaveBeenCalledWith('rule-1');
+    // Note: t() mock doesn't handle placeholders, so we just check it was called
+    expect(mockedToast.success).toHaveBeenCalled();
+  });
+
+  it('should show delete confirmation dialog', async () => {
+    const user = userEvent.setup();
+    mockedRuleStorage.getAll.mockReturnValue([mockRule]);
+
+    render(<RuleManager {...defaultProps} />);
+
+    const deleteButton = screen.getByTitle('删除');
+    await user.click(deleteButton);
+
+    expect(screen.getByText(/确定要删除规则/)).toBeInTheDocument();
+  });
+
+  it('should delete rule after confirmation', async () => {
+    const user = userEvent.setup();
+    mockedRuleStorage.getAll.mockReturnValue([mockRule]);
+
+    render(<RuleManager {...defaultProps} />);
+
+    // Open delete dialog
+    await user.click(screen.getByTitle('删除'));
+
+    // Confirm delete
+    await user.click(screen.getByText('确认'));
+
+    expect(mockedRuleStorage.deleteRule).toHaveBeenCalledWith('rule-1');
+    expect(mockedToast.success).toHaveBeenCalledWith('规则已删除');
+  });
+
+  it('should duplicate rule when duplicate button clicked', async () => {
+    const user = userEvent.setup();
+    mockedRuleStorage.getAll.mockReturnValue([mockRule]);
+    mockedRuleStorage.duplicate.mockReturnValue({
+      ...mockRule,
+      id: 'rule-2',
+      name: 'Test Rule（副本）',
+    });
+
+    render(<RuleManager {...defaultProps} />);
+
+    await user.click(screen.getByTitle('复制'));
+
+    expect(mockedRuleStorage.duplicate).toHaveBeenCalledWith('rule-1', '（副本）');
+    expect(mockedToast.success).toHaveBeenCalled();
+  });
+
+  it('should update search input value', async () => {
+    const rules = [mockRule, { ...mockRule, id: 'rule-2', name: 'Another Rule' }];
+    mockedRuleStorage.getAll.mockReturnValue(rules);
+
+    render(<RuleManager {...defaultProps} />);
+
+    // Initially both rules should be visible
+    expect(screen.getByText('Test Rule')).toBeInTheDocument();
+    expect(screen.getByText('Another Rule')).toBeInTheDocument();
+
+    // Verify search input exists and is interactive
+    const searchInput = screen.getByPlaceholderText('搜索规则...');
+    expect(searchInput).toBeInTheDocument();
+    expect(searchInput).toHaveValue('');
+  });
+
+  it('should call exportRules when export button clicked', async () => {
+    const user = userEvent.setup();
+    mockedRuleStorage.getAll.mockReturnValue([mockRule]);
+
+    render(<RuleManager {...defaultProps} />);
+
+    // Mock URL methods and body methods after render to avoid interfering with createRoot
+    const mockCreateObjectURL = vi.fn(() => 'blob:mock');
+    const mockRevokeObjectURL = vi.fn();
+    vi.spyOn(URL, 'createObjectURL').mockImplementation(mockCreateObjectURL);
+    vi.spyOn(URL, 'revokeObjectURL').mockImplementation(mockRevokeObjectURL);
+    vi.spyOn(document.body, 'appendChild').mockImplementation(() => null as unknown as Node);
+    vi.spyOn(document.body, 'removeChild').mockImplementation(() => null as unknown as Node);
+
+    const buttons = screen.getAllByRole('button');
+    const exportButton = buttons.find((btn) => btn.textContent?.includes('导出'));
+    expect(exportButton).toBeDefined();
+
+    await user.click(exportButton!);
+
+    expect(mockedRuleStorage.exportRules).toHaveBeenCalled();
+    expect(mockCreateObjectURL).toHaveBeenCalled();
+
+    vi.restoreAllMocks();
+  });
+
+  it('should show field count for each rule', () => {
+    mockedRuleStorage.getAll.mockReturnValue([mockRule]);
+
+    render(<RuleManager {...defaultProps} />);
+
+    // The component shows "{count} 字段" format
+    expect(screen.getByText(/字段/)).toBeInTheDocument();
+  });
+});

src/pages/TestDataGenerator/hooks/useGenerator.ts

@@ -0,0 +1,148 @@
+/**
+ * 数据生成器 Hook
+ * 管理 Web Worker 的创建、销毁和通信
+ */
+
+import { useState, useRef, useCallback, useEffect } from 'react';
+import type {
+  FieldConfig,
+  GenerateResult,
+  GenerateProgress,
+  WorkerMessage,
+} from '@/types/testDataGenerator';
+
+export interface UseGeneratorReturn {
+  /** 是否正在生成 */
+  isGenerating: boolean;
+  /** 生成进度 */
+  progress: GenerateProgress | null;
+  /** 生成结果 */
+  result: GenerateResult | null;
+  /** 错误信息 */
+  error: string | null;
+  /** 开始生成 */
+  generate: (fields: FieldConfig[], count: number, csvMode?: boolean) => void;
+  /** 取消生成 */
+  cancel: () => void;
+  /** 清除结果 */
+  clearResult: () => void;
+}
+
+export function useGenerator(): UseGeneratorReturn {
+  const [isGenerating, setIsGenerating] = useState(false);
+  const [progress, setProgress] = useState<GenerateProgress | null>(null);
+  const [result, setResult] = useState<GenerateResult | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const workerRef = useRef<Worker | null>(null);
+
+  // 清理 Worker
+  useEffect(() => {
+    return () => {
+      if (workerRef.current) {
+        workerRef.current.terminate();
+        workerRef.current = null;
+      }
+    };
+  }, []);
+
+  /**
+   * 创建或复用 Worker
+   */
+  const getWorker = useCallback((): Worker => {
+    if (workerRef.current) {
+      return workerRef.current;
+    }
+
+    const worker = new Worker(new URL('@/workers/generator.worker.ts', import.meta.url), {
+      type: 'module',
+    });
+
+    worker.onmessage = (e: MessageEvent<WorkerMessage>) => {
+      const data = e.data;
+      const { type } = data;
+
+      switch (type) {
+        case 'progress':
+          setProgress(data.payload as GenerateProgress);
+          break;
+        case 'complete':
+          setIsGenerating(false);
+          setResult(data.payload as GenerateResult);
+          setProgress(null);
+          break;
+        case 'error':
+          setIsGenerating(false);
+          setError((data.payload as { error: string }).error);
+          setProgress(null);
+          break;
+      }
+    };
+
+    worker.onerror = (err) => {
+      console.error('[useGenerator] Worker 错误:', err);
+      setIsGenerating(false);
+      setError(err.message || 'Worker 运行错误');
+      setProgress(null);
+      // Worker 出错后销毁，下次重新创建
+      workerRef.current?.terminate();
+      workerRef.current = null;
+    };
+
+    workerRef.current = worker;
+    return worker;
+  }, []);
+
+  /**
+   * 开始生成
+   */
+  const generate = useCallback(
+    (fields: FieldConfig[], count: number, csvMode = false) => {
+      if (isGenerating) return;
+
+      setIsGenerating(true);
+      setProgress(null);
+      setResult(null);
+      setError(null);
+
+      const worker = getWorker();
+      const message: WorkerMessage = {
+        type: 'start',
+        payload: { fields, count, csvMode },
+      };
+      worker.postMessage(message);
+    },
+    [isGenerating, getWorker],
+  );
+
+  /**
+   * 取消生成
+   */
+  const cancel = useCallback(() => {
+    if (workerRef.current && isGenerating) {
+      const message: WorkerMessage = { type: 'cancel' };
+      workerRef.current.postMessage(message);
+      setIsGenerating(false);
+      setProgress(null);
+    }
+  }, [isGenerating]);
+
+  /**
+   * 清除结果
+   */
+  const clearResult = useCallback(() => {
+    setResult(null);
+    setProgress(null);
+    setError(null);
+  }, []);
+
+  return {
+    isGenerating,
+    progress,
+    result,
+    error,
+    generate,
+    cancel,
+    clearResult,
+  };
+}

src/pages/TestDataGenerator/index.tsx

@@ -0,0 +1,306 @@
+/**
+ * 测试数据生成器主页面
+ */
+
+import { useState, useCallback, useRef, useEffect } from 'react';
+import { Settings, Database, Tag } from 'lucide-react';
+import { useI18n } from '@/utils/chromeI18n';
+import { cn } from '@/lib/utils';
+import { useGenerator } from './hooks/useGenerator';
+import type { FieldConfig, GenerateResult, DataRule } from '@/types/testDataGenerator';
+import { Dialog, DialogContent } from '@/components/ui/dialog';
+import { Button } from '@/components/ui/button';
+import { toast } from 'sonner';
+
+// 生成唯一 ID 的辅助函数
+function generateId(): string {
+  return `field_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+
+import FieldList, { MAX_FIELDS } from './components/FieldList';
+import FieldEditor from './components/FieldEditor';
+import GenerateOptions from './components/GenerateOptions';
+import GenerateButton from './components/GenerateButton';
+import DataPreview from './components/DataPreview';
+import ResultPanel from './components/ResultPanel';
+import ExportPanel from './components/ExportPanel';
+import RuleManager from './components/RuleManager';
+
+type TabType = 'fields' | 'rules';
+
+export default function TestDataGeneratorPage() {
+  const { t } = useI18n('testDataGenerator');
+  const { isGenerating, progress, result, error, generate, cancel, clearResult } = useGenerator();
+
+  // 字段配置
+  const [fields, setFields] = useState<FieldConfig[]>([]);
+  const [selectedIndex, setSelectedIndex] = useState<number | null>(null);
+  const [isEditorOpen, setIsEditorOpen] = useState(false);
+  const [editingRule, setEditingRule] = useState<DataRule | null>(null);
+
+  // 生成选项
+  const [count, setCount] = useState(100);
+  const [format, setFormat] = useState<'json' | 'csv'>('json');
+
+  // 当前标签页
+  const [activeTab, setActiveTab] = useState<TabType>('fields');
+
+  // 生成完成时显示 toast 提示（避免重复触发）
+  const lastToastResultRef = useRef<GenerateResult | null>(null);
+
+  // 生成完成时显示 toast 提示（避免重复触发）
+  useEffect(() => {
+    if (result?.success && result.stats && result !== lastToastResultRef.current) {
+      lastToastResultRef.current = result;
+      toast.success(t('testDataGenerator_generateSuccess'), {
+        description: `${result.stats.total} ${t('testDataGenerator_records')}`,
+      });
+    }
+  }, [result, t]);
+
+  // 添加新字段
+  const handleAddField = useCallback(() => {
+    setFields((prev) => {
+      if (prev.length >= MAX_FIELDS) return prev;
+      const newField: FieldConfig = {
+        id: generateId(),
+        name: `field${prev.length + 1}`,
+        generatorId: 'chineseName',
+        params: {},
+        required: true,
+        nullRate: 0,
+        unique: false,
+      };
+      setSelectedIndex(prev.length);
+      return [...prev, newField];
+    });
+  }, []);
+
+  // 更新字段
+  const handleUpdateField = useCallback((index: number, field: FieldConfig) => {
+    setFields((prev) => {
+      const newFields = [...prev];
+      newFields[index] = field;
+      return newFields;
+    });
+  }, []);
+
+  // 删除字段
+  const handleRemoveField = useCallback((index: number) => {
+    setFields((prev) => prev.filter((_, i) => i !== index));
+    setSelectedIndex((prev) => {
+      if (prev === index) return null;
+      if (prev !== null && prev > index) return prev - 1;
+      return prev;
+    });
+  }, []);
+
+  // 拖拽排序
+  const handleReorder = useCallback((oldIndex: number, newIndex: number) => {
+    setFields((prev) => {
+      const newFields = [...prev];
+      const [moved] = newFields.splice(oldIndex, 1);
+      newFields.splice(newIndex, 0, moved);
+      return newFields;
+    });
+    setSelectedIndex((prev) => {
+      if (prev === oldIndex) return newIndex;
+      if (prev !== null) {
+        if (oldIndex < prev && newIndex >= prev) return prev - 1;
+        if (oldIndex > prev && newIndex <= prev) return prev + 1;
+      }
+      return prev;
+    });
+  }, []);
+
+  // 加载规则
+  const handleLoadRule = useCallback(
+    (loadedFields: FieldConfig[]) => {
+      setFields(loadedFields);
+      setSelectedIndex(null);
+      setEditingRule(null);
+      clearResult();
+    },
+    [clearResult],
+  );
+
+  // 编辑规则
+  const handleEditRule = useCallback(
+    (rule: DataRule) => {
+      setFields(rule.fields);
+      setSelectedIndex(null);
+      setEditingRule(rule);
+      setActiveTab('fields');
+      clearResult();
+      toast.success(t('testDataGenerator_editingRule', { name: rule.name }));
+    },
+    [clearResult, t],
+  );
+
+  // 保存规则成功后清除编辑状态
+  const handleRuleSaved = useCallback(() => {
+    setEditingRule(null);
+  }, []);
+
+  // 开始生成
+  const handleGenerate = useCallback(() => {
+    if (fields.length === 0) return;
+    generate(fields, count, format === 'csv');
+  }, [fields, count, format, generate]);
+
+  // 获取选中的字段（-1 或 null 表示未选中）
+  const selectedField = selectedIndex !== null && selectedIndex >= 0 ? fields[selectedIndex] : null;
+
+  // 打开字段编辑器
+  const handleOpenEditor = useCallback((index: number) => {
+    setSelectedIndex(index);
+    setIsEditorOpen(true);
+  }, []);
+
+  return (
+    <div className="min-h-screen bg-background text-foreground antialiased selection:bg-primary/20">
+      <div className="max-w-7xl mx-auto p-4 sm:p-6">
+        {/* 主要内容区域 - 左右分栏 */}
+        <div className="grid grid-cols-1 lg:grid-cols-5 gap-4 items-start">
+          {/* 左侧面板 - 字段配置 */}
+          <div className="lg:col-span-3 space-y-4">
+            {/* 标签页切换 */}
+            <div className="flex gap-1 p-1 bg-muted rounded-lg">
+              <button
+                onClick={() => setActiveTab('fields')}
+                className={cn(
+                  'flex-1 flex items-center justify-center gap-2 py-2 px-3 text-sm font-medium rounded-md transition-colors',
+                  activeTab === 'fields'
+                    ? 'bg-background text-foreground shadow-sm'
+                    : 'text-muted-foreground hover:text-foreground',
+                )}
+              >
+                <Settings className="h-4 w-4" />
+                {t('testDataGenerator_fieldConfig')}
+              </button>
+              <button
+                onClick={() => setActiveTab('rules')}
+                className={cn(
+                  'flex-1 flex items-center justify-center gap-2 py-2 px-3 text-sm font-medium rounded-md transition-colors',
+                  activeTab === 'rules'
+                    ? 'bg-background text-foreground shadow-sm'
+                    : 'text-muted-foreground hover:text-foreground',
+                )}
+              >
+                <Tag className="h-4 w-4" />
+                {t('testDataGenerator_ruleManagement')}
+              </button>
+            </div>
+
+            {/* 字段配置标签页 */}
+            {activeTab === 'fields' && (
+              <div className="p-4 rounded-xl border border-border bg-card shadow-sm">
+                <FieldList
+                  fields={fields}
+                  onUpdate={handleUpdateField}
+                  onRemove={handleRemoveField}
+                  onAdd={handleAddField}
+                  onEdit={handleOpenEditor}
+                  onReorder={handleReorder}
+                  editingRule={editingRule}
+                  onRuleSaved={handleRuleSaved}
+                />
+              </div>
+            )}
+
+            {/* 规则管理标签页 */}
+            {activeTab === 'rules' && (
+              <div className="p-4 rounded-xl border border-border bg-card shadow-sm">
+                <RuleManager onLoad={handleLoadRule} onEdit={handleEditRule} />
+              </div>
+            )}
+
+            {/* 生成选项 */}
+            <div className="p-4 rounded-xl border border-border bg-card shadow-sm">
+              <GenerateOptions
+                count={count}
+                onCountChange={setCount}
+                format={format}
+                onFormatChange={setFormat}
+              />
+            </div>
+
+            {/* 生成按钮 */}
+            <div className="p-4 rounded-xl border border-border bg-card shadow-sm">
+              <GenerateButton
+                onClick={handleGenerate}
+                onCancel={cancel}
+                isGenerating={isGenerating}
+                progress={progress}
+                disabled={fields.length === 0}
+              />
+            </div>
+          </div>
+
+          {/* 右侧面板 - 数据预览和结果 */}
+          <div className="lg:col-span-2 space-y-4">
+            {/* 结果状态 */}
+            {/* 仅在失败或有警告时显示结果面板 */}
+            {((result && !result.success) ||
+              (result?.warnings && result.warnings.length > 0) ||
+              error) && (
+              <div className="p-4 rounded-xl border border-border bg-card shadow-sm">
+                {error ? (
+                  <div className="flex items-center gap-2 text-destructive">
+                    <span className="text-sm">{error}</span>
+                  </div>
+                ) : (
+                  <ResultPanel result={result} />
+                )}
+              </div>
+            )}
+
+            {/* 数据预览 */}
+            <div className="p-4 rounded-xl border border-border bg-card shadow-sm">
+              <h3 className="text-sm font-medium text-foreground mb-3 flex items-center gap-2">
+                <Database className="h-4 w-4" />
+                {t('testDataGenerator_dataPreview')}
+              </h3>
+              <div className="h-[280px]">
+                <DataPreview fields={fields} />
+              </div>
+            </div>
+
+            {/* 导出面板 */}
+            {result?.data && result.data.length > 0 && (
+              <div className="p-4 rounded-xl border border-border bg-card shadow-sm">
+                <ExportPanel result={result} />
+              </div>
+            )}
+          </div>
+        </div>
+      </div>
+
+      {/* 字段编辑弹窗 */}
+      <Dialog open={isEditorOpen} onOpenChange={setIsEditorOpen}>
+        <DialogContent
+          showCloseButton={false}
+          className="w-[calc(100vw-2rem)] max-w-[520px] max-h-[calc(100vh-2rem)] p-0 pt-6 flex flex-col"
+        >
+          <div className="flex-1 overflow-y-auto px-6 pb-4">
+            {selectedField && selectedIndex !== null && (
+              <FieldEditor
+                field={selectedField}
+                onChange={(updatedField) => handleUpdateField(selectedIndex, updatedField)}
+                allFieldNames={fields.map((f) => f.name)}
+              />
+            )}
+          </div>
+          <div className="flex justify-end gap-2 px-6 py-2 border-t shrink-0">
+            <Button variant="ghost" size="sm" onClick={() => setIsEditorOpen(false)}>
+              {t('testDataGenerator_cancel')}
+            </Button>
+            <Button size="sm" onClick={() => setIsEditorOpen(false)}>
+              {t('testDataGenerator_done')}
+            </Button>
+          </div>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}