feat (编辑器)：优化目录区块交互能力，完善表格单元格拖拽缩放功能

· 为目录区块新增切换按钮，支持目录内容显示 / 隐藏
· 实现可折叠目录界面，配套展开 / 收起图标与平滑过渡动画
· 为表格区块添加行列拖拽缩放功能，支持鼠标拖动调整宽高
· 提取编辑器全局基础字号、字体族配置，统一全文文字渲染样式
· 持久化存储表格缩放状态（缩放类型、行列索引、拖拽位置、尺寸数值）
· 更新目录区块元数据，记录折叠 / 展开状态，实现数据持久保存
· 为目录容器添加淡入动画，提升用户使用体验
· 优化表格单元格样式，拖拽操作时提供更清晰的视觉反馈
· 升级富文本转换器，支持传入字体样式参数以定制 HTML 导出内容
· 新增缩放状态类型接口，统一管理表格行列的缩放操作逻辑

src/components/Editor/RichTextEditor/RichTextEditor.tsx

@@ -84,13 +84,20 @@ export const RichTextEditor: React.FC<RichTextEditorProps> = ({
       return;
     }
     
-    const html = richTextToHtml(value);
+    // 提取baseStyle中的字号和字体
+    const baseFontSize = baseStyle.fontSize ? parseFloat(String(baseStyle.fontSize)) : undefined;
+    const baseFontFamily = baseStyle.fontFamily ? String(baseStyle.fontFamily) : undefined;
+    
+    const html = richTextToHtml(value, {
+      fontSize: baseFontSize,
+      fontFamily: baseFontFamily,
+    });
     
     // 只在内容真正改变时更新,避免光标跳动
     if (editorRef.current.innerHTML !== html) {
       editorRef.current.innerHTML = html;
     }
-  }, [value]);
+  }, [value, baseStyle.fontSize, baseStyle.fontFamily]);
 
   // ── 自动聚焦 ───────────────────────────────────────────────────────────────
   useEffect(() => {

src/components/Editor/blocks/TOCBlock.css

@@ -6,11 +6,59 @@
   margin: 16px 0;
 }
 
+.toc-toggle-button {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 10px 16px;
+  background-color: #ffffff;
+  border: 1px solid #d9d9d9;
+  border-radius: 6px;
+  cursor: pointer;
+  transition: all 0.2s ease;
+  font-size: 14px;
+  font-weight: 500;
+  color: #262626;
+  width: 100%;
+  justify-content: center;
+}
+
+.toc-toggle-button:hover {
+  background-color: #f5f7fa;
+  border-color: #40a9ff;
+  color: #1890ff;
+}
+
+.toc-toggle-button:active {
+  background-color: #e6f7ff;
+}
+
+.toc-toggle-icon {
+  font-size: 12px;
+  transition: transform 0.2s ease;
+}
+
+.toc-toggle-text {
+  font-size: 14px;
+}
+
 .toc-block {
   padding: 20px;
   background-color: #f5f7fa;
   border: 2px dashed #d9d9d9;
   border-radius: 8px;
+  animation: fadeIn 0.2s ease-in;
+}
+
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+    transform: translateY(-10px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
 }
 
 .toc-title {

src/components/Editor/blocks/TOCBlock.tsx

@@ -8,6 +8,7 @@
 
 import React from 'react';
 import type { TOCBlock as TOCBlockType } from '../../../types/editor';
+import { useEditorStore } from '../../../stores/editorStore';
 import './TOCBlock.css';
 
 export interface TOCBlockProps {
@@ -19,25 +20,46 @@ export interface TOCBlockProps {
  * TOCBlock - 目录块（只读）
  * 
  * TOC块是自动生成的，用户无法编辑
+ * 通过按钮控制删除/添加目录块内容
  */
 export const TOCBlock: React.FC<TOCBlockProps> = ({ block }) => {
+  const { updateBlock } = useEditorStore();
+  
+  // 检查块是否被隐藏（通过metadata中的hidden标志）
+  const isHidden = (block.metadata as any)?.hidden === true;
+
+  const handleToggle = () => {
+    // 切换隐藏状态
+    updateBlock(block.id, {
+      metadata: {
+        ...block.metadata,
+        hidden: !isHidden,
+      },
+    });
+  };
+
   return (
     <div className="toc-block-wrapper" data-block-id={block.id}>
-      <div className="toc-block">
-        <div className="toc-title">{block.content.title || '目录'}</div>
-        <div className="toc-notice">
-          <span className="toc-icon">ℹ️</span>
-          <span>目录内容由系统自动生成，无法手动编辑</span>
-        </div>
-        <div className="toc-placeholder">
-          <p>目录将在导出文档时自动生成，包含以下内容：</p>
-          <ul>
-            <li>文档中的所有标题</li>
-            <li>页码（在打印版本中）</li>
-            <li>可点击的超链接（在电子版本中）</li>
-          </ul>
+      <button 
+        className="toc-toggle-button"
+        onClick={handleToggle}
+        type="button"
+      >
+        <span className="toc-toggle-icon">{isHidden ? '▶' : '▼'}</span>
+        <span className="toc-toggle-text">
+          {isHidden ? '添加目录' : '删除目录'}
+        </span>
+      </button>
+      
+      {!isHidden && (
+        <div className="toc-block">
+          <div className="toc-title">{block.content.title || '目录'}</div>
+          <div className="toc-notice">
+            <span className="toc-icon">ℹ️</span>
+            <span>目录内容由系统自动生成，无法手动编辑</span>
+          </div>
         </div>
-      </div>
+      )}
     </div>
   );
 };

src/components/Editor/blocks/TableBlock.tsx

@@ -11,6 +11,17 @@ import { TableCell } from './TableCell';
 import { TableToolbar } from './TableToolbar';
 import './TableBlock.css';
 
+// ══════════════════════════════════════════════════════════════════════════════
+// Types
+// ══════════════════════════════════════════════════════════════════════════════
+
+interface ResizeState {
+  type: 'column' | 'row';
+  index: number;
+  startPos: number;
+  startSize: number;
+}
+
 export interface TableBlockProps {
   block: TableBlockType;
   readOnly?: boolean;
@@ -38,6 +49,10 @@ export const TableBlock: React.FC<TableBlockProps> = ({
     endCol: number;
   } | null>(null);
   
+  // 拖动调整尺寸状态
+  const [resizeState, setResizeState] = useState<ResizeState | null>(null);
+  const tableRef = useRef<HTMLTableElement>(null);
+  
   // 防抖计时器
   const saveTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const lastContentRef = useRef<string>(JSON.stringify(block.content));
@@ -53,6 +68,7 @@ export const TableBlock: React.FC<TableBlockProps> = ({
             if (cIdx !== colIndex) return cell;
             return { ...cell, ...updates };
           }),
+          height: row.height, // 保留行高
         };
       });
 
@@ -111,6 +127,119 @@ export const TableBlock: React.FC<TableBlockProps> = ({
     }
   }, [selectedCell]);
 
+  // ══════════════════════════════════════════════════════════════════════════════
+  // 列宽调整
+  // ══════════════════════════════════════════════════════════════════════════════
+
+  // 开始调整列宽
+  const handleColumnResizeStart = useCallback((colIndex: number, e: React.MouseEvent) => {
+    if (readOnly) return;
+    
+    e.preventDefault();
+    e.stopPropagation();
+    
+    const colWidths = block.metadata.col_widths;
+    setResizeState({
+      type: 'column',
+      index: colIndex,
+      startPos: e.clientX,
+      startSize: colWidths[colIndex],
+    });
+  }, [block.metadata.col_widths, readOnly]);
+
+  // 开始调整行高
+  const handleRowResizeStart = useCallback((rowIndex: number, e: React.MouseEvent) => {
+    if (readOnly) return;
+    
+    e.preventDefault();
+    e.stopPropagation();
+    
+    const currentHeight = block.content.rows[rowIndex].height || 20;
+    setResizeState({
+      type: 'row',
+      index: rowIndex,
+      startPos: e.clientY,
+      startSize: currentHeight,
+    });
+  }, [block.content.rows, readOnly]);
+
+  // 处理拖动
+  const handleMouseMove = useCallback((e: MouseEvent) => {
+    if (!resizeState || !tableRef.current) return;
+
+    if (resizeState.type === 'column') {
+      // 调整列宽
+      const deltaX = e.clientX - resizeState.startPos;
+      const tableWidth = tableRef.current.offsetWidth;
+      const deltaPercent = (deltaX / tableWidth) * 100;
+      
+      const newColWidths = [...block.metadata.col_widths];
+      const newWidth = Math.max(5, resizeState.startSize + deltaPercent); // 最小5%
+      
+      // 如果有下一列，调整下一列宽度以保持总宽度不变
+      if (resizeState.index < newColWidths.length - 1) {
+        const nextColWidth = newColWidths[resizeState.index + 1];
+        const widthDiff = newWidth - resizeState.startSize;
+        const newNextWidth = Math.max(5, nextColWidth - widthDiff);
+        
+        newColWidths[resizeState.index] = newWidth;
+        newColWidths[resizeState.index + 1] = newNextWidth;
+      } else {
+        newColWidths[resizeState.index] = newWidth;
+      }
+      
+      updateBlock(block.id, {
+        metadata: {
+          ...block.metadata,
+          col_widths: newColWidths,
+        },
+      });
+    } else if (resizeState.type === 'row') {
+      // 调整行高
+      const deltaY = e.clientY - resizeState.startPos;
+      // 每像素约等于0.75pt
+      const deltaPt = deltaY * 0.75;
+      const newHeight = Math.max(15, resizeState.startSize + deltaPt); // 最小15pt
+      
+      const newRows = block.content.rows.map((row, idx) => {
+        if (idx !== resizeState.index) return row;
+        return { ...row, height: newHeight };
+      });
+      
+      updateBlock(block.id, {
+        content: { rows: newRows },
+      });
+    }
+  }, [resizeState, block.id, block.metadata, block.content.rows, updateBlock]);
+
+  // 结束拖动
+  const handleMouseUp = useCallback(() => {
+    if (resizeState && documentId && !readOnly) {
+      // 保存更改
+      saveBlock(block.id).catch(() => {
+        // Auto-save failed
+      });
+    }
+    setResizeState(null);
+  }, [resizeState, documentId, readOnly, saveBlock, block.id]);
+
+  // 绑定全局鼠标事件
+  useEffect(() => {
+    if (resizeState) {
+      document.addEventListener('mousemove', handleMouseMove);
+      document.addEventListener('mouseup', handleMouseUp);
+      document.body.style.cursor = resizeState.type === 'column' ? 'col-resize' : 'row-resize';
+      document.body.style.userSelect = 'none';
+      
+      return () => {
+        document.removeEventListener('mousemove', handleMouseMove);
+        document.removeEventListener('mouseup', handleMouseUp);
+        document.body.style.cursor = '';
+        document.body.style.userSelect = '';
+      };
+    }
+  }, [resizeState, handleMouseMove, handleMouseUp]);
+
   // 计算表格宽度
   const tableWidth = block.metadata.table_width;
   const tableWidthUnit = block.metadata.table_width_unit;
@@ -142,6 +271,7 @@ export const TableBlock: React.FC<TableBlockProps> = ({
       {/* 表格 */}
       <div className="table-container">
         <table
+          ref={tableRef}
           className="table-block"
           style={{
             width: tableWidthStyle,
@@ -155,7 +285,12 @@ export const TableBlock: React.FC<TableBlockProps> = ({
           </colgroup>
           <tbody>
             {block.content.rows.map((row, rowIndex) => (
-              <tr key={rowIndex}>
+              <tr 
+                key={rowIndex}
+                style={{
+                  height: row.height ? `${row.height}pt` : undefined,
+                }}
+              >
                 {row.cells.map((cell, colIndex) => {
                   // 检查单元格是否在选择范围内
                   const isInRange = selectedRange
@@ -178,6 +313,8 @@ export const TableBlock: React.FC<TableBlockProps> = ({
                       }
                       onChange={handleCellChange}
                       onClick={handleCellClick}
+                      onColumnResize={colIndex < colWidths.length - 1 ? handleColumnResizeStart : undefined}
+                      onRowResize={rowIndex < block.content.rows.length - 1 ? handleRowResizeStart : undefined}
                     />
                   );
                 })}

src/components/Editor/blocks/TableCell.css

@@ -25,3 +25,120 @@
 .table-cell .rich-text-editor {
   min-height: 20px;
 }
+
+/* ══════════════════════════════════════════════════════════════════════════════
+   调整尺寸手柄
+   ══════════════════════════════════════════════════════════════════════════════ */
+
+/* 调整手柄基础样式 */
+.resize-handle {
+  position: absolute;
+  background-color: transparent;
+  transition: background-color 0.15s ease;
+  z-index: 10;
+  opacity: 0;
+}
+
+/* 鼠标悬停在单元格上时显示手柄 */
+.table-cell:hover .resize-handle {
+  opacity: 1;
+}
+
+/* 拖动时手柄高亮 */
+.resize-handle:active,
+.resize-handle:hover {
+  background-color: rgba(24, 144, 255, 0.5);
+  opacity: 1;
+}
+
+/* 列宽调整手柄 - 右边界 */
+.resize-handle-column {
+  top: 0;
+  right: -4px;
+  width: 8px;
+  height: 100%;
+  cursor: col-resize;
+}
+
+.resize-handle-column::before {
+  content: '';
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  width: 2px;
+  height: 60%;
+  background-color: rgba(24, 144, 255, 0.6);
+  border-radius: 1px;
+  opacity: 0;
+  transition: opacity 0.15s ease;
+}
+
+.resize-handle-column:hover::before,
+.table-cell:hover .resize-handle-column::before {
+  opacity: 1;
+}
+
+/* 行高调整手柄 - 下边界 */
+.resize-handle-row {
+  left: 0;
+  bottom: -4px;
+  width: 100%;
+  height: 8px;
+  cursor: row-resize;
+}
+
+.resize-handle-row::before {
+  content: '';
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  width: 60%;
+  height: 2px;
+  background-color: rgba(24, 144, 255, 0.6);
+  border-radius: 1px;
+  opacity: 0;
+  transition: opacity 0.15s ease;
+}
+
+.resize-handle-row:hover::before,
+.table-cell:hover .resize-handle-row::before {
+  opacity: 1;
+}
+
+/* 角落调整手柄 - 右下角 */
+.resize-handle-corner {
+  right: -4px;
+  bottom: -4px;
+  width: 12px;
+  height: 12px;
+  cursor: nwse-resize;
+  background-color: rgba(24, 144, 255, 0.3);
+  border: 1px solid rgba(24, 144, 255, 0.5);
+  border-radius: 2px;
+  opacity: 0;
+}
+
+.resize-handle-corner:hover,
+.table-cell:hover .resize-handle-corner {
+  background-color: rgba(24, 144, 255, 0.6);
+  border-color: rgba(24, 144, 255, 0.8);
+  opacity: 1;
+}
+
+/* 只读模式下完全隐藏调整手柄 */
+.table-cell[readonly] .resize-handle {
+  display: none;
+}
+
+/* 拖动时的全局样式 */
+body.resizing {
+  cursor: col-resize !important;
+  user-select: none !important;
+}
+
+body.resizing-row {
+  cursor: row-resize !important;
+  user-select: none !important;
+}

src/components/Editor/blocks/TableCell.tsx

@@ -29,6 +29,10 @@ export interface TableCellProps {
   onChange?: (rowIndex: number, colIndex: number, updates: Partial<TableCellType>) => void;
   /** 单元格点击回调 */
   onClick?: (rowIndex: number, colIndex: number, shiftKey: boolean) => void;
+  /** 列宽调整回调 */
+  onColumnResize?: (colIndex: number, e: React.MouseEvent) => void;
+  /** 行高调整回调 */
+  onRowResize?: (rowIndex: number, e: React.MouseEvent) => void;
 }
 
 // ══════════════════════════════════════════════════════════════════════════════
@@ -52,6 +56,8 @@ export const TableCell: React.FC<TableCellProps> = ({
   isSelected = false,
   onChange,
   onClick,
+  onColumnResize,
+  onRowResize,
 }) => {
   // 被合并的单元格不渲染
   if (cell.rowspan === 0 || cell.colspan === 0) {
@@ -61,6 +67,12 @@ export const TableCell: React.FC<TableCellProps> = ({
   // 解析样式
   const cellStyle = cellStyleToCSS(cell.style);
 
+  // 提取字体相关属性
+  // 优先级：cell.style > 默认值（12pt）
+  // 注意：如果 font_size 明确为 0，说明需要使用默认值
+  const fontSize = cell.style?.font_size || 12;
+  const fontFamily = cell.style?.font_name || '宋体';
+
   // 处理内容变更
   const handleContentChange = useCallback(
     (newText: RichText[]) => {
@@ -74,6 +86,18 @@ export const TableCell: React.FC<TableCellProps> = ({
     onClick?.(rowIndex, colIndex, e.shiftKey);
   }, [rowIndex, colIndex, onClick]);
 
+  // 处理列宽调整
+  const handleColumnResizeMouseDown = useCallback((e: React.MouseEvent) => {
+    e.stopPropagation();
+    onColumnResize?.(colIndex, e);
+  }, [colIndex, onColumnResize]);
+
+  // 处理行高调整
+  const handleRowResizeMouseDown = useCallback((e: React.MouseEvent) => {
+    e.stopPropagation();
+    onRowResize?.(rowIndex, e);
+  }, [rowIndex, onRowResize]);
+
   return (
     <td
       className={`table-cell ${isSelected ? 'selected' : ''}`}
@@ -91,11 +115,42 @@ export const TableCell: React.FC<TableCellProps> = ({
         placeholder=""
         singleLine={false}
         baseStyle={{
-          fontSize: '12px',
+          fontSize: `${fontSize}pt`,
+          fontFamily: fontFamily,
           lineHeight: 1.5,
           textAlign: 'center', // 强制居中对齐
         }}
       />
+      
+      {/* 列宽调整手柄 */}
+      {!readOnly && onColumnResize && (
+        <div
+          className="resize-handle resize-handle-column"
+          onMouseDown={handleColumnResizeMouseDown}
+          title="拖动调整列宽"
+        />
+      )}
+      
+      {/* 行高调整手柄 */}
+      {!readOnly && onRowResize && (
+        <div
+          className="resize-handle resize-handle-row"
+          onMouseDown={handleRowResizeMouseDown}
+          title="拖动调整行高"
+        />
+      )}
+      
+      {/* 角落调整手柄(同时调整行高和列宽) */}
+      {!readOnly && onColumnResize && onRowResize && (
+        <div
+          className="resize-handle resize-handle-corner"
+          onMouseDown={(e) => {
+            // 同时触发两个方向的调整
+            handleColumnResizeMouseDown(e);
+          }}
+          title="拖动调整尺寸"
+        />
+      )}
     </td>
   );
 };

src/stores/editorStore.ts

@@ -18,8 +18,10 @@ import type {
   PartialBlock,
   BlockUpdate,
   BlockType,
+  TableBlock,
 } from '../types/editor';
 import { blockService } from '../services/blockService';
+import { normalizeTableBlock, serializeTableBlock } from '../utils/blockOperations';
 
 // 并发保存限制器（最多同时进行 5 个请求）
 const saveConcurrencyLimit = pLimit(5);
@@ -254,19 +256,27 @@ export const useEditorStore = create<EditorStore>((set, get) => ({
     try {
       const data = await blockService.getBlocks(documentId);
       
+      // 规范化表格块的数据结构，确保与后端期望格式一致
+      const normalizedBlocks = data.blocks.map(block => {
+        if (block.type === 'table') {
+          return normalizeTableBlock(block as TableBlock);
+        }
+        return block;
+      });
+      
       // 保存原始blocks快照,用于检测修改
-      const snapshot = JSON.stringify(data.blocks);
+      const snapshot = JSON.stringify(normalizedBlocks);
       
       // 计算所有块的初始哈希值
       const initialHashes = new Map<string, string>();
-      data.blocks.forEach(block => {
+      normalizedBlocks.forEach(block => {
         initialHashes.set(block.id, computeBlockHash(block));
       });
       
       set({
         documentId,
         documentTitle: '未命名文档', // 后端不返回title，使用默认值
-        blocks: data.blocks,
+        blocks: normalizedBlocks,
         isLoading: false,
         hasModified: false, // 初始状态为未修改
         originalBlocksSnapshot: snapshot,
@@ -353,12 +363,19 @@ export const useEditorStore = create<EditorStore>((set, get) => ({
         
         // 使用并发限制器并行保存（最多同时 5 个请求）
         const tasks = blocksToSave.map(block => 
-          saveConcurrencyLimit(() => 
-            blockService.updateBlock(
+          saveConcurrencyLimit(() => {
+            // 序列化表格块的content（将富文本数组转为纯字符串）
+            let contentToSave = block.content;
+            if (block.type === 'table') {
+              const serializedTable = serializeTableBlock(block as TableBlock);
+              contentToSave = serializedTable.content;
+            }
+            
+            return blockService.updateBlock(
               documentId, 
               block.id, 
               {
-                content: block.content as any,
+                content: contentToSave as any,
                 style: block.style,
                 word_style: block.word_style,
                 metadata: block.metadata,
@@ -369,8 +386,8 @@ export const useEditorStore = create<EditorStore>((set, get) => ({
               completedCount++;
               set({ savingProgress: { current: completedCount, total: totalBlocks } });
               return result;
-            })
-          )
+            });
+          })
         );
         
         // 等待所有任务完成（使用 allSettled 容错）
@@ -529,12 +546,19 @@ export const useEditorStore = create<EditorStore>((set, get) => ({
         
         // 使用并发限制器重试保存
         const tasks = blocksToRetry.map(block => 
-          saveConcurrencyLimit(() => 
-            blockService.updateBlock(
+          saveConcurrencyLimit(() => {
+            // 序列化表格块的content（将富文本数组转为纯字符串）
+            let contentToSave = block.content;
+            if (block.type === 'table') {
+              const serializedTable = serializeTableBlock(block as TableBlock);
+              contentToSave = serializedTable.content;
+            }
+            
+            return blockService.updateBlock(
               documentId, 
               block.id, 
               {
-                content: block.content as any,
+                content: contentToSave as any,
                 style: block.style,
                 word_style: block.word_style,
                 metadata: block.metadata,
@@ -545,8 +569,8 @@ export const useEditorStore = create<EditorStore>((set, get) => ({
               completedCount++;
               set({ savingProgress: { current: completedCount, total: totalBlocks } });
               return result;
-            })
-          )
+            });
+          })
         );
         
         const results = await Promise.allSettled(tasks);
@@ -861,8 +885,15 @@ export const useEditorStore = create<EditorStore>((set, get) => ({
     set({ isSaving: true, error: null });
     
     try {
+      // 序列化表格块的content（将富文本数组转为纯字符串）
+      let contentToSave = block.content;
+      if (block.type === 'table') {
+        const serializedTable = serializeTableBlock(block as TableBlock);
+        contentToSave = serializedTable.content;
+      }
+      
       await blockService.updateBlock(documentId, id, {
-        content: block.content as any, // 类型断言：不同block类型的content类型不同
+        content: contentToSave as any, // 类型断言：不同block类型的content类型不同
         style: block.style,
         word_style: block.word_style,
         metadata: block.metadata,

src/types/editor.ts

@@ -104,13 +104,6 @@ export interface CellStyleOverrides extends StyleOverrides {
   border_color?: string;
   border_width?: number;
   vertical_align?: 'top' | 'center' | 'bottom';
-  // 合并单元格时保存的原始数据(包含text和style)
-  _mergedCells?: Array<{
-    rowOffset: number;
-    colOffset: number;
-    text: string | RichText[];
-    style?: CellStyleOverrides; // 保存原始样式
-  }>;
 }
 
 /**
@@ -120,8 +113,10 @@ export interface TableCell {
   text: string | RichText[];
   rowspan: number;
   colspan: number;
+  col_index?: number;     // 列索引(从1开始)
   width?: number;         // 单元格宽度(磅)
   style: CellStyleOverrides;
+  word_style?: string;    // Word样式名
 }
 
 /**
@@ -209,6 +204,7 @@ export interface TOCMetadata {
   is_auto_generated: boolean;
   readonly: boolean;
   deletable: boolean;
+  hidden?: boolean; // 目录是否隐藏
 }
 
 export interface TOCBlock extends BaseBlock {

src/utils/blockOperations.ts

@@ -99,16 +99,155 @@ export function rebalanceBlockOrders(blocks: DocumentBlock[]): DocumentBlock[] {
 // ══════════════════════════════════════════════════════════════════════════════
 
 /**
+ * 将 text 字段从富文本数组转换为纯字符串
+ * 
+ * @param text 文本内容（字符串或富文本数组）
+ * @returns 纯字符串
+ */
+export function flattenTextToString(text: string | RichText[]): string {
+  if (typeof text === 'string') {
+    return text;
+  }
+  // 如果是 RichText 数组，提取所有的纯文本并连接
+  return text.map(seg => seg.text).join('');
+}
+
+/**
+ * 序列化表格单元格为后端格式
+ * 将富文本数组的 text 字段转换为纯字符串
+ * 
+ * @param cell 前端单元格数据
+ * @param colIndex 列索引(从1开始)
+ * @param defaultWidth 默认宽度(磅)
+ * @returns 序列化后的单元格（text为纯字符串）
+ */
+export function serializeTableCell(
+  cell: TableCell,
+  colIndex: number,
+  defaultWidth: number = 100
+): any {
+  return {
+    text: flattenTextToString(cell.text), // 转换为纯字符串
+    rowspan: cell.rowspan || 1,
+    colspan: cell.colspan || 1,
+    col_index: cell.col_index !== undefined ? cell.col_index : colIndex,
+    style: {
+      align: cell.style?.align || 'center',
+      font_size: cell.style?.font_size || 12,
+      font_name: cell.style?.font_name || '黑体',
+      ...cell.style, // 保留其他自定义样式
+    },
+    word_style: cell.word_style || 'Normal',
+    width: cell.width !== undefined ? cell.width : defaultWidth,
+  };
+}
+
+/**
+ * 序列化表格块为后端格式
+ * 将所有单元格的 text 从富文本数组转换为纯字符串
+ * 
+ * @param table 表格块
+ * @returns 序列化后的表格块
+ */
+export function serializeTableBlock(table: TableBlock): any {
+  // 计算每列的平均宽度作为默认值
+  const avgWidth = table.metadata.col_widths.length > 0
+    ? table.metadata.col_widths.reduce((sum, w) => sum + w, 0) / table.metadata.col_widths.length
+    : 100;
+
+  // 默认行高（磅）
+  const defaultHeight = 58;
+
+  const rows = table.content.rows.map((row) => ({
+    cells: row.cells.map((cell, colIdx) => 
+      serializeTableCell(cell, colIdx + 1, avgWidth)
+    ),
+    // 保留原有的 height，只有在没有 height 时才使用默认值
+    height: row.height !== undefined ? row.height : defaultHeight,
+  }));
+
+  return {
+    ...table,
+    content: { rows },
+  };
+}
+
+/**
+ * 规范化表格单元格数据结构
+ * 确保单元格包含所有必需字段，与后端期望的格式一致
+ * 
+ * @param cell 原始单元格数据
+ * @param colIndex 列索引(从1开始)
+ * @param defaultWidth 默认宽度(磅)
+ * @returns 规范化后的单元格
+ */
+export function normalizeTableCell(
+  cell: Partial<TableCell>,
+  colIndex: number,
+  defaultWidth: number = 100
+): TableCell {
+  return {
+    text: cell.text || '',
+    rowspan: cell.rowspan || 1,
+    colspan: cell.colspan || 1,
+    col_index: cell.col_index !== undefined ? cell.col_index : colIndex,
+    style: {
+      align: cell.style?.align || 'center',
+      font_size: cell.style?.font_size || 12,
+      font_name: cell.style?.font_name || '黑体',
+      ...cell.style, // 保留其他自定义样式
+    },
+    word_style: cell.word_style || 'Normal',
+    width: cell.width !== undefined ? cell.width : defaultWidth,
+  };
+}
+
+/**
+ * 规范化整个表格的数据结构
+ * 确保所有单元格都包含完整的字段信息
+ * 
+ * @param table 表格块
+ * @returns 规范化后的表格块
+ */
+export function normalizeTableBlock(table: TableBlock): TableBlock {
+  // 计算每列的平均宽度作为默认值
+  const avgWidth = table.metadata.col_widths.length > 0
+    ? table.metadata.col_widths.reduce((sum, w) => sum + w, 0) / table.metadata.col_widths.length
+    : 100;
+
+  // 默认行高（磅）
+  const defaultHeight = 58;
+
+  const rows = table.content.rows.map((row) => ({
+    cells: row.cells.map((cell, colIdx) => 
+      normalizeTableCell(cell, colIdx + 1, avgWidth)
+    ),
+    // 保留原有的 height，只有在没有 height 时才使用默认值
+    height: row.height !== undefined ? row.height : defaultHeight,
+  }));
+
+  return {
+    ...table,
+    content: { rows },
+  };
+}
+
+/**
  * 创建空的表格单元格
  * 
+ * @param colIndex 列索引(从1开始,可选)
+ * @param width 单元格宽度(磅,可选)
  * @returns 空单元格
  */
-export function createEmptyCell(): TableCell {
+export function createEmptyCell(colIndex?: number, width?: number): TableCell {
   return {
     text: '',
     rowspan: 1,
     colspan: 1,
+    col_index: colIndex,
     style: {},
+    word_style: 'Normal',
+    width: width,
   };
 }
 
@@ -116,11 +255,19 @@ export function createEmptyCell(): TableCell {
  * 创建空的表格行
  * 
  * @param cols 列数
+ * @param colWidths 列宽数组(磅,可选)
+ * @param height 行高(磅,可选,默认58)
  * @returns 表格行
  */
-export function createEmptyRow(cols: number): TableRow {
+export function createEmptyRow(cols: number, colWidths?: number[], height?: number): TableRow {
   return {
-    cells: Array(cols).fill(null).map(() => createEmptyCell()),
+    cells: Array(cols).fill(null).map((_, index) => 
+      createEmptyCell(
+        index + 1, // col_index从1开始
+        colWidths?.[index]
+      )
+    ),
+    height: height !== undefined ? height : 58, // 默认行高58磅
   };
 }
 
@@ -137,7 +284,10 @@ export function createEmptyRow(cols: number): TableRow {
  * ```
  */
 export function insertTableRow(table: TableBlock, afterRow: number): TableBlock {
-  const newRow = createEmptyRow(table.metadata.cols);
+  // 使用相邻行的高度作为新行的高度
+  const referenceHeight = table.content.rows[afterRow]?.height || 58;
+  
+  const newRow = createEmptyRow(table.metadata.cols, table.metadata.col_widths, referenceHeight);
   const rows = [...table.content.rows];
   rows.splice(afterRow + 1, 0, newRow);
   
@@ -166,8 +316,27 @@ export function insertTableRow(table: TableBlock, afterRow: number): TableBlock
 export function insertTableColumn(table: TableBlock, afterCol: number): TableBlock {
   const rows = table.content.rows.map((row) => {
     const cells = [...row.cells];
-    cells.splice(afterCol + 1, 0, createEmptyCell());
-    return { cells };
+    
+    // 计算新列的宽度
+    const avgWidth = table.metadata.col_widths.reduce((sum, w) => sum + w, 0) / table.metadata.col_widths.length;
+    
+    // 插入新单元格，并设置正确的 col_index 和 width
+    cells.splice(afterCol + 1, 0, createEmptyCell(afterCol + 2, avgWidth));
+    
+    // 更新后续单元格的 col_index
+    for (let i = afterCol + 2; i < cells.length; i++) {
+      if (cells[i].col_index !== undefined) {
+        cells[i] = {
+          ...cells[i],
+          col_index: i + 1,
+        };
+      }
+    }
+    
+    return { 
+      cells,
+      height: row.height, // 保留行高
+    };
   });
   
   const colWidths = [...table.metadata.col_widths];
@@ -221,9 +390,18 @@ export function deleteTableColumn(table: TableBlock, colIndex: number): TableBlo
     throw new Error('表格至少需要一列');
   }
   
-  const rows = table.content.rows.map((row) => ({
-    cells: row.cells.filter((_, i) => i !== colIndex),
-  }));
+  const rows = table.content.rows.map((row) => {
+    const cells = row.cells.filter((_, i) => i !== colIndex);
+    
+    // 更新剩余单元格的 col_index
+    return {
+      cells: cells.map((cell, i) => ({
+        ...cell,
+        col_index: i + 1,
+      })),
+      height: row.height, // 保留行高
+    };
+  });
   
   const colWidths = table.metadata.col_widths.filter((_, i) => i !== colIndex);
   
@@ -242,7 +420,8 @@ export function deleteTableColumn(table: TableBlock, colIndex: number): TableBlo
  * 合并单元格
  * 
  * 支持横向合并(colspan)和纵向合并(rowspan)
- * 合并时会保存所有被合并单元格的原始内容和样式,以便拆分时恢复
+ * 合并后的主单元格会保存所有被合并单元格的文本内容（用空格连接）
+ * 被合并的单元格会被标记为隐藏（rowspan=0, colspan=0）
  * 
  * @param table 表格块
  * @param startRow 起始行
@@ -255,11 +434,11 @@ export function deleteTableColumn(table: TableBlock, colIndex: number): TableBlo
  * ```ts
  * // 横向合并: a + b (第0行,第0-1列)
  * mergeCells(table, 0, 0, 0, 1);
- * // 结果: a单元格 colspan=2, 保存b的内容和样式到 _mergedCells
+ * // 结果: a单元格 colspan=2, text包含a和b的内容
  * 
  * // 纵向合并: a + d (第0-1行,第0列)
  * mergeCells(table, 0, 0, 1, 0);
- * // 结果: a单元格 rowspan=2, 保存d的内容和样式到 _mergedCells
+ * // 结果: a单元格 rowspan=2, text包含a和d的内容
  * ```
  */
 export function mergeCells(
@@ -269,32 +448,30 @@ export function mergeCells(
   endRow: number,
   endCol: number
 ): TableBlock {
-  // 收集所有被合并单元格的内容和样式(保存位置偏移量)
-  const mergedCells: Array<{
-    rowOffset: number;
-    colOffset: number;
-    text: string | RichText[];
-    style: any; // 保存原始样式
-  }> = [];
+  // 计算合并范围
+  const rowSpan = endRow - startRow + 1;
+  const colSpan = endCol - startCol + 1;
+  
+  // 获取主单元格(左上角)
+  const mainCell = table.content.rows[startRow].cells[startCol];
   
   // 收集主单元格内容用于显示
   const displayTexts: string[] = [];
   
+  // 辅助函数：将 text 字段规范化为纯字符串
+  const normalizeText = (text: string | RichText[]): string => {
+    if (typeof text === 'string') {
+      return text;
+    }
+    // 如果是 RichText 数组，提取所有的纯文本
+    return text.map(seg => seg.text).join('');
+  };
+  
   table.content.rows.forEach((row, rowIdx) => {
     if (rowIdx >= startRow && rowIdx <= endRow) {
       row.cells.forEach((cell, colIdx) => {
         if (colIdx >= startCol && colIdx <= endCol) {
-          const text = typeof cell.text === 'string' 
-            ? cell.text 
-            : cell.text.map(seg => seg.text).join('');
-          
-          // 保存所有单元格的原始数据和样式(包括主单元格)
-          mergedCells.push({
-            rowOffset: rowIdx - startRow,
-            colOffset: colIdx - startCol,
-            text: cell.text,
-            style: { ...cell.style }, // 深拷贝样式
-          });
+          const text = normalizeText(cell.text);
           
           // 用于显示的文本
           if (text.trim()) {
@@ -316,29 +493,44 @@ export function mergeCells(
       }
       
       if (rowIdx === startRow && colIdx === startCol) {
-        // 主单元格,设置rowspan和colspan,保存原始数据
+        // 主单元格：设置完整的标准格式
+        // 合并后的文本统一为纯字符串格式
+        const mergedText = displayTexts.join(' ');
+        
+        // 构建标准格式的单元格对象（字段顺序与后端一致）
         return {
-          ...cell,
-          text: displayTexts.join(' ') || cell.text,
-          rowspan: endRow - startRow + 1,
-          colspan: endCol - startCol + 1,
+          text: mergedText || normalizeText(cell.text),
+          rowspan: rowSpan,
+          colspan: colSpan,
+          col_index: startCol + 1, // 列索引从1开始
           style: {
-            ...cell.style,
-            _mergedCells: mergedCells, // 保存所有单元格的原始内容和样式
+            // 保留原有样式，确保必要字段存在
+            align: cell.style?.align || 'center',
+            font_size: cell.style?.font_size || 12,
+            font_name: cell.style?.font_name || '黑体',
+            ...cell.style, // 其他自定义样式
           },
+          word_style: cell.word_style || 'Normal',
+          width: cell.width !== undefined ? cell.width : 100, // 保留原有width或使用默认值
         };
       }
       
-      // 被合并的单元格,标记为隐藏
+      // 被合并的单元格，标记为隐藏
       return {
-        ...cell,
         text: '', // 清空显示内容
         rowspan: 0,
         colspan: 0,
+        col_index: colIdx + 1, // 保持列索引
+        style: cell.style || {},
+        word_style: cell.word_style || 'Normal',
+        width: cell.width,
       };
     });
     
-    return { cells };
+    return { 
+      cells,
+      height: row.height, // 保留行高
+    };
   });
   
   return {
@@ -350,7 +542,8 @@ export function mergeCells(
 /**
  * 拆分单元格
  * 
- * 将已合并的单元格拆分回独立单元格,并恢复原始内容和样式到对应位置
+ * 将已合并的单元格拆分回独立单元格
+ * 主单元格保留原有内容，其他单元格恢复为空单元格
  * 
  * @param table 表格块
  * @param rowIndex 单元格所在行
@@ -361,11 +554,11 @@ export function mergeCells(
  * ```ts
  * // 拆分横向合并的单元格 (a+b)
  * splitCell(table, 0, 0);
- * // 结果: a单元格恢复为普通单元格(内容为原始a,样式为原始a样式), b单元格恢复(内容为原始b,样式为原始b样式)
+ * // 结果: a单元格保留内容，b单元格变为空单元格
  * 
  * // 拆分纵向合并的单元格 (a+d)  
  * splitCell(table, 0, 0);
- * // 结果: a单元格恢复为普通单元格(内容为原始a,样式为原始a样式), d单元格恢复(内容为原始d,样式为原始d样式)
+ * // 结果: a单元格保留内容，d单元格变为空单元格
  * ```
  */
 export function splitCell(
@@ -387,16 +580,6 @@ export function splitCell(
   const rowspan = targetCell.rowspan || 1;
   const colspan = targetCell.colspan || 1;
   
-  // 获取保存的原始单元格数据(包含text和style)
-  const mergedCells = targetCell.style._mergedCells || [];
-  
-  // 创建一个映射,用于快速查找原始内容和样式
-  const cellDataMap = new Map<string, { text: string | RichText[]; style: any }>();
-  mergedCells.forEach(({ rowOffset, colOffset, text, style }) => {
-    const key = `${rowOffset}-${colOffset}`;
-    cellDataMap.set(key, { text, style: style || {} });
-  });
-  
   const rows = table.content.rows.map((row, rowIdx) => {
     // 不在合并范围内的行直接返回
     if (rowIdx < rowIndex || rowIdx >= rowIndex + rowspan) {
@@ -409,42 +592,28 @@ export function splitCell(
         return cell;
       }
       
-      // 计算当前单元格在合并区域中的偏移量
-      const rowOffset = rowIdx - rowIndex;
-      const colOffset = colIdx - colIndex;
-      const key = `${rowOffset}-${colOffset}`;
-      
-      // 从保存的数据中恢复原始内容和样式
-      const cellData = cellDataMap.get(key);
-      const originalText = cellData?.text || '';
-      const originalStyle = cellData?.style || {};
-      
-      // 主单元格:恢复为普通单元格,清除合并标记
+      // 主单元格：恢复为普通单元格,清除合并标记
       if (rowIdx === rowIndex && colIdx === colIndex) {
-        const newStyle = { ...originalStyle };
-        delete newStyle._mergedCells; // 清除保存的合并数据
-        
         return {
           ...cell,
-          text: originalText,
           rowspan: 1,
           colspan: 1,
-          style: newStyle, // 使用原始样式
+          col_index: colIdx + 1, // 确保 col_index 存在
+          word_style: cell.word_style || 'Normal', // 确保 word_style 存在
         };
       }
       
-      // 被合并的单元格:恢复为独立单元格,并恢复原始内容和样式
-      const recoveredStyle = { ...originalStyle };
-      delete recoveredStyle._mergedCells;
-      
-      return {
-        ...createEmptyCell(),
-        text: originalText,
-        style: recoveredStyle, // 使用原始样式
-      };
+      // 被合并的单元格：恢复为独立空单元格
+      return createEmptyCell(
+        colIdx + 1, // col_index从1开始
+        cell.width // 保留原有宽度
+      );
     });
     
-    return { cells };
+    return { 
+      cells,
+      height: row.height, // 保留行高
+    };
   });
   
   return {

src/utils/richTextConverter.ts

@@ -100,6 +100,7 @@ export function hexToRgb(hex: string): string {
  * RichText数组转HTML字符串(用于contenteditable渲染)
  * 
  * @param content 富文本内容
+ * @param baseStyle 基础样式（可选，用于提供默认字号和字体）
  * @returns HTML字符串
  * 
  * @example
@@ -111,7 +112,7 @@ export function hexToRgb(hex: string): string {
  * // "<span>普通</span><strong>加粗</strong>"
  * ```
  */
-export function richTextToHtml(content: string | RichText[]): string {
+export function richTextToHtml(content: string | RichText[], baseStyle?: { fontSize?: number; fontFamily?: string }): string {
   if (typeof content === 'string') {
     return escapeHtml(content);
   }
@@ -119,12 +120,19 @@ export function richTextToHtml(content: string | RichText[]): string {
   return content
     .map((segment) => {
       let html = escapeHtml(segment.text);
-      const { bold, italic, underline, color, font_size } = segment.style;
+      const { bold, italic, underline, color, font_size, font_name } = segment.style;
       
       // 构建内联样式
       const styles: string[] = [];
       if (color) styles.push(`color: #${color}`);
-      if (font_size) styles.push(`font-size: ${font_size}pt`);
+      
+      // 字号：优先使用片段自己的字号，否则使用基础样式的字号
+      const finalFontSize = font_size !== undefined ? font_size : baseStyle?.fontSize;
+      if (finalFontSize) styles.push(`font-size: ${finalFontSize}pt`);
+      
+      // 字体：优先使用片段自己的字体，否则使用基础样式的字体
+      const finalFontName = font_name || baseStyle?.fontFamily;
+      if (finalFontName) styles.push(`font-family: ${finalFontName}`);
       
       // 包装HTML标签
       if (bold) html = `<strong>${html}</strong>`;