Scripts/Grid Selected Text.md · wk/obsidian

/* 此文件是个混合脚本，用功能选择器选择3种不同功能。
1、Grid Selected Text：能将选定的分组元素排列成紧凑的网格视图，去除元素之间的间隙，并自动添加行列分隔线。
2、editTableLayout：添加行、列
```javascript
*/

/**
 * 动态加载模块
 * @param {string} filePath - 模块文件路径
 * @returns {Promise<Object>} 模块导出的API对象
 */
const loadModule = async (filePath) => {
    try {
        // 1. 获取模块内容
        const fileContent = await app.vault.adapter.read(filePath);
        
        // 2. 提取JavaScript代码（改进的解析逻辑）
        let jsCode = null;
        
        // 尝试第一种代码块格式
        const codeBlockRegex = /```(?:javascript|js)([\s\S]*?)```/;
        const match = fileContent.match(codeBlockRegex);
        
        if (match && match[1]) {
            jsCode = match[1].trim();
        } 
        // 尝试第二种代码块格式
        else {
            const altRegex = /```(?:javascript|js)\n([\s\S]*?)\n```/;
            const altMatch = fileContent.match(altRegex);
            if (altMatch && altMatch[1]) {
                jsCode = altMatch[1].trim();
            }
        }
        
        // 3. 如果还是没找到，尝试解析整个文件内容
        if (!jsCode) {
            // 检查文件是否以函数定义开头
            if (fileContent.includes("function") || fileContent.includes("const") || fileContent.includes("return")) {
                jsCode = fileContent;
            } else {
                throw new Error(`Module ${filePath} does not contain valid JavaScript code`);
            }
        }
        
        // 4. 创建沙箱环境执行代码
        const sandbox = {};
        const moduleExports = {};
        
        const functionWrapper = new Function(
            'exports',
            `
                try {
                    ${jsCode}
                    return exports;
                } catch (e) {
                    console.error("Module execution error:", e);
                    throw e;
                }
            `
        );
        
        return functionWrapper.call(sandbox, moduleExports);
    } catch (e) {
        console.error(`Error loading module ${filePath}:`, e);
        throw new Error(`Failed to load module: ${e.message}`);
    }
};
// ======模块加载结束 ======================

// 主函数
(async function() {
  try {
    // 加载对话框模块
    const DialogUtils = await loadModule("Excalidraw/Module/DialogUtils.md");
    
    // 使用自定义确认对话框选择功能
    const functionResult = await DialogUtils.createCustomDialog(
      "选择功能",
      "请选择需要执行的功能",
      ["创建表格", "添加行", "添加列"]
    );
    
    // 根据选择执行相应功能
    if (functionResult === 0) {
      // 功能1: 创建表格
      await createGridLayout(DialogUtils);
    } else if (functionResult === 1) {
      // 功能3: 添加行
      await editTableLayout(DialogUtils, true); // true表示添加行
    } else if (functionResult === 2) {
      // 功能4: 添加列
      await editTableLayout(DialogUtils, false); // false表示添加列
    }
  } catch (error) {
    console.error("脚本执行出错:", error);
    new Notice(`脚本执行出错: ${error.message}`, 5000);
  } finally {
    // 无论脚本执行成功还是失败，都执行清理操作
    cleanupResources();
  }
})();

// ====================== 功能1: 创建表格 ======================
async function createGridLayout(DialogUtils) {
  try {
    // 用于记录表格的所有元素
    const tableElements = [];
    
    //▌▌▌▌步骤1: 获取表格列数
    const colCountInput = await DialogUtils.createMiniInputDialog("表格列数", "请输入所需表格的列数", "3");
    if (colCountInput == null) {
      new Notice("操作已取消", 3000);
      return;
    }
    
    const colCount = Number(colCountInput);
    if (!colCount || colCount < 1) {
      new Notice("无效列数", 3000);
      return;
    }

const api = ea.getExcalidrawAPI();
    let columns = [];
    let originPoint = null;
    const spacing = 6;

// 计算分组边界框
    const computeBoundingBox = (elements) => {
      let minX = Infinity, minY = Infinity, 
          maxX = -Infinity, maxY = -Infinity;
      
      elements.forEach(el => {
        minX = Math.min(minX, el.x);
        minY = Math.min(minY, el.y);
        maxX = Math.max(maxX, el.x + (el.width || 0));
        maxY = Math.max(maxY, el.y + (el.height || 0));
      });
      
      return { 
        topX: minX, 
        topY: minY, 
        width: maxX - minX,
        height: maxY - minY
      };
    };

//▌▌▌▌步骤2: 逐列选择元素
    for (let currentCol = 0; currentCol < colCount; currentCol++) {
      let blocks = [];
      let confirmed = false;
      let timeout = 3;

while (!confirmed && timeout > 0) {
        new Notice(`请框选第 ${currentCol + 1}/${colCount} 列\n剩余时间：${timeout}秒`);
        await new Promise(r => setTimeout(r, 3000));

const initiallySelected = ea.getViewSelectedElements();
        const groupIds = new Set(initiallySelected.flatMap(el => el.groupIds || []));
        const groupElements = ea.getElements().filter(el => 
          el.groupIds?.some(id => groupIds.has(id))
        );
        const selectedElements = [...new Set([...initiallySelected, ...groupElements])];

const elementMap = new Map();
        selectedElements.forEach(el => {
          const key = el.groupIds?.[0] || el.id;
          if (!elementMap.has(key)) elementMap.set(key, []);
          elementMap.get(key).push(el);
        });

blocks = Array.from(elementMap.values())
          .map(elements => ({
            elements,
            bbox: computeBoundingBox(elements)
          }))
          .filter(block => block.elements.length > 0);

if (blocks.length > 0) {
          blocks.sort((a, b) => a.bbox.topY - b.bbox.topY);
          
          // 使用自定义确认对话框
          const dialogResult = await DialogUtils.createCustomDialog(
            "列选择确认", 
            `第 ${currentCol + 1}/${colCount} 列，已选择 ${blocks.length} 个区块`, 
            ["取消操作", "重新框选", "确定选择"]
          );
          
          if (dialogResult === 2) { // 确定选择
            confirmed = true;
          } else if (dialogResult === 0 || dialogResult === null) { // 取消操作或关闭对话框
            new Notice("操作已取消", 3000);
            return;
          } else if (dialogResult === 1) { // 重新框选
            timeout = 6; // 重置超时计数器
            continue;
          }
        }
        timeout--;
      }

if (!confirmed || blocks.length === 0) {
        new Notice("操作已超时");
        return;
      }

columns.push({
        blocks: blocks,
        width: Math.max(...blocks.map(b => b.bbox.width))
      });

if (currentCol === 0 && blocks[0]) {
        originPoint = { 
          x: blocks[0].bbox.topX, 
          y: blocks[0].bbox.topY 
        };
      }

// 记录用户选择的元素
      blocks.forEach(block => {
        tableElements.push(...block.elements);
      });

api.setActiveTool({ type: "hand" });
      api.setActiveTool({ type: "selection" });
      api.refresh();
    }

//▌▌▌▌步骤3: 动态计算行高
    const maxRows = Math.max(...columns.map(c => c.blocks.length));
    const rows = Array.from({ length: maxRows }, (_, rowIndex) => ({
      height: Math.max(...columns.map(c => 
        rowIndex < c.blocks.length 
          ? c.blocks[rowIndex].bbox.height
          : 0
      )) + (rowIndex < maxRows - 1 ? spacing : 0)
    }));

//▌▌▌▌步骤4: 调整元素布局
    let currentX = originPoint.x;
    columns.forEach(col => {
      let currentY = originPoint.y;
      col.blocks.forEach((block, rowIdx) => {
        const offsetX = currentX - block.bbox.topX;
        const offsetY = currentY - block.bbox.topY;
        block.elements.forEach(el => {
          el.x += offsetX;
          el.y += offsetY;
        });
        currentY += rows[rowIdx].height;
      });
      currentX += col.width + spacing;
    });

//▌▌▌▌步骤5: 绘制分隔线
    const totalWidth = columns.reduce((sum, c) => sum + c.width, 0) + 
                      (columns.length - 1) * spacing;
    const totalHeight = rows.reduce((sum, r) => sum + r.height, 0);

// 绘制行分隔线
    const separatorLines = [];
    rows.slice(0, -1).forEach((_, i) => {
      const y = originPoint.y + 
               rows.slice(0, i + 1).reduce((s, r) => s + r.height, 0) - 
               spacing / 2;
      ea.style.strokeColor = "#000000";
      ea.style.roughness = 0;
      const lineId = ea.addLine([
        [originPoint.x - 3, y],
        [originPoint.x + totalWidth + 3, y]
      ]);
      const line = ea.getElement(lineId);
      separatorLines.push(line);
      tableElements.push(line);
    });

// 绘制列分隔线
    columns.slice(0, -1).reduce((acc, col, i) => {
      const x = acc + col.width + spacing / 2;
      ea.style.strokeColor = "#000000";
      ea.style.roughness = 0;
      const lineId = ea.addLine([
        [x, originPoint.y - 3],
        [x, originPoint.y + totalHeight + 3]
      ]);
      const line = ea.getElement(lineId);
      separatorLines.push(line);
      tableElements.push(line);
      return acc + col.width + spacing;
    }, originPoint.x);

// 现在计算包围框 - 基于重新排列后的元素位置
    const allLayoutElements = [...tableElements];
    const box = computeBoundingBox(allLayoutElements);
    
    //▌▌▌▌步骤6: 添加0 padding的基础包围框
    if (allLayoutElements.length > 0) {
      // 设置包围框样式
      ea.style.strokeColor = "black";
      ea.style.roughness = 0;
      const padding = 0; // padding设置为0
      
      const rectId = ea.addRect(
        box.topX - padding,
        box.topY - padding,
        box.width + padding * 2,
        box.height + padding * 2
      );
      const rect = ea.getElement(rectId);
      tableElements.push(rect); // 将包围框添加到表格元素列表
    }
    
    // 添加到视图
    ea.copyViewElementsToEAforEditing(tableElements);
    await ea.addElementsToView(false, false, true);
    
    // 询问是否添加第一行/第一列色块
    const highlightResult = await DialogUtils.createCustomDialog(
      "添加表头高亮",
      "请选择表头的位置",
      ["取消", "第一行", "第一列"]
    );
    
    const highlightRects = []; // 存储高亮矩形对象
    const highlightElements = []; // 存储高亮矩形元素对象
    
    if (highlightResult === 1 || highlightResult === 2) {
      // 计算表格单元格位置 - 基于重新排列后的布局
      const cells = [];
      let y = originPoint.y;
      
      for (let row = 0; row < maxRows; row++) {
        let x = originPoint.x;
        const rowHeight = rows[row].height - (row < maxRows - 1 ? spacing : 0);
        
        for (let col = 0; col < colCount; col++) {
          const colWidth = columns[col].width;
          
          cells.push({
            row,
            col,
            x,
            y,
            width: colWidth,
            height: rowHeight
          });
          
          x += colWidth + spacing;
        }
        
        y += rows[row].height;
      }
      
      // 颜色设置对话框函数
      async function getHeaderBackgroundColor() {
        // 弹出颜色设置对话框
        const colorInput = await DialogUtils.createMiniInputDialog(
          "设置表头颜色",
          "请输入十六进制颜色代码",
          "a5d8ff"
        );
        
        // 验证颜色输入并格式化
        if (colorInput) {
          // 移除可能的空格并确保颜色格式正确
          const trimmedColor = colorInput.trim();
          // 如果没有#前缀，添加#
          const formattedColor = trimmedColor.startsWith('#') ? trimmedColor : `#${trimmedColor}`;
          // 简单验证是否为有效的十六进制颜色格式
          if (/^#[0-9A-Fa-f]{6}$/.test(formattedColor) || /^#[0-9A-Fa-f]{3}$/.test(formattedColor)) {
            return formattedColor;
          }
        }
        // 默认颜色
        return "#a5d8ff";
      }
      
      // 获取用户设置的背景颜色
      const bgColor = await getHeaderBackgroundColor();
      
      // 设置表头高亮矩形样式
      ea.style.strokeColor = "transparent";
      ea.style.backgroundColor = bgColor;
      ea.style.fillStyle = 'solid';
      ea.style.roughness = 0;
      ea.style.opacity = 100;
      
      // 添加第一行色块
      if (highlightResult === 1) {
        for (let col = 0; col < colCount; col++) {
          const cell = cells.find(c => c.row === 0 && c.col === col);
          if (cell) {
            const rectId = ea.addRect(
              cell.x - 3,
              cell.y - 3,
              cell.width + 6,
              cell.height + 6
            );
            const rect = ea.getElement(rectId);
            highlightRects.push(rect);
            highlightElements.push(rect);
          }
        }
      }
      // 添加第一列色块
      else if (highlightResult === 2) {
        for (let row = 0; row < maxRows; row++) {
          const cell = cells.find(c => c.row === row && c.col === 0);
          if (cell) {
            const rectId = ea.addRect(
              cell.x - 3,
              cell.y - 3,
              cell.width + 6,
              cell.height + 6
            );
            const rect = ea.getElement(rectId);
            highlightRects.push(rect);
            highlightElements.push(rect);
          }
        }
      }
      
      // 将蓝色背景矩形添加到视图并置于底层
      if (highlightElements.length > 0) {
        ea.copyViewElementsToEAforEditing(highlightElements);
        ea.addElementsToView(false, false, false); // 置于底层
      }
    }
    
    // 将表格元素和蓝色背景矩形合并到一个分组
    if (tableElements.length > 0 || highlightElements.length > 0) {
      // 创建包含所有元素的数组
      const allGroupElements = [...tableElements, ...highlightElements];
      
      // 获取所有元素的ID
      const elementIds = allGroupElements.map(el => el.id);
      
      // 创建分组
      ea.copyViewElementsToEAforEditing(allGroupElements);
      ea.addToGroup(elementIds);
      
      // 更新视图
      await ea.addElementsToView(false, true, true);
    }
    
    new Notice("表格创建成功！", 2000);
  } catch (err) {
    console.error("创建表格出错:", err);
    new Notice(`创建表格出错: ${err.message}`, 3000);
  }
}

// ====================== 功能2: 添加序号======================
async function addCellBackground(DialogUtils) {
  
    // 获取当前选中的元素
const selectedElements = ea.getViewSelectedElements();

// 验证选择：必须且只能选择一个文本元素
if (selectedElements.length !== 1 || selectedElements[0].type !== "text") {
    new Notice("请选择单个文本元素");
    return;
}

// 获取原始文本元素
const elementA = selectedElements[0];
const originalText = elementA.text || "";

// 设置测量环境
ea.style.fontFamily = elementA.fontFamily;
ea.style.fontSize = elementA.fontSize;

// 测量字符位置
const measurements = [];
let currentPos = 0;

for (let i = 0; i < originalText.length; i++) {
    const substring = originalText.slice(0, i + 1);
    const totalWidth = ea.measureText(substring).width;
    measurements.push({
        start: currentPos,
        end: totalWidth,
        char: originalText[i]
    });
    currentPos = totalWidth;
}

// 加载 TextMeasurerPanel 模块
let TextMeasurerPanel = null;
let cleanupPanel = null;

try {
    // 使用模块加载器加载面板模块
    TextMeasurerPanel = await loadModule("Excalidraw/Module/TextMeasurerPanel.md");
    
    // 定义面板关闭时的回调函数
    const onClose = () => {
        try {
            if (cleanupPanel) {
                cleanupPanel();
                cleanupPanel = null;
            }
            if (TextMeasurerPanel && TextMeasurerPanel.cleanup) {
                TextMeasurerPanel.cleanup();
            }
            new Notice("字符序号面板已关闭");
        } catch (e) {
            console.error("关闭面板时出错:", e);
        }
    };
    
    // 创建字符序号面板
    const panelResult = TextMeasurerPanel.TextMeasurerPanel.create(originalText, measurements, onClose);
    cleanupPanel = panelResult.cleanup;
    
    new Notice("字符序号面板已创建", 3000);
} catch (e) {
    console.error("加载或创建字符序号面板时出错:", e);
    new Notice(`加载或创建字符序号面板时出错: ${e.message}`, 5000);
    
    // 清理资源
    try {
        if (cleanupPanel) {
            cleanupPanel();
        }
        if (TextMeasurerPanel && TextMeasurerPanel.cleanup) {
            TextMeasurerPanel.cleanup();
        }
    } catch (cleanupError) {
        console.error("清理资源时出错:", cleanupError);
    }
}
  
}

// 解除编组函数
function ungroupElements(elements) {
  const ungroupedElements = [];
  
  elements.forEach(element => {
    // 如果元素有groupIds，则解除编组
    if (element.groupIds && element.groupIds.length > 0) {
      const ungroupedElement = { ...element };
      ungroupedElement.groupIds = [];
      ungroupedElements.push(ungroupedElement);
    } else {
      ungroupedElements.push(element);
    }
  });
  
  return ungroupedElements;
}

// ====================== 功能3: 表格编辑功能 ======================
async function editTableLayout(DialogUtils, isAddRow) {
  try {
    // 获取当前选中的元素
    const selectedElements = ea.getViewSelectedElements();
    if (selectedElements.length === 0) {
      new Notice("请先选择表格元素", 3000);
      return;
    }

// 第一次尝试解析表格结构（静默模式，不显示错误提示）
    let tableData = await parseTableStructureSilent(selectedElements);
    
    // 如果第一次解析失败，尝试解除编组后再次解析
    if (!tableData) {
      new Notice("第一次表格解析失败，尝试解除编组后重新解析...", 3000);
      
      // 解除编组
      const ungroupedElements = ungroupElements(selectedElements);
      
      // 第二次尝试解析表格结构
      tableData = await parseTableStructure(ungroupedElements);
      
      if (!tableData) {
        new Notice("表格解析失败，无法识别表格结构", 3000);
        return;
      }
      
      new Notice("表格解析成功！", 2000);
    }

// 记录原有区块元素的ID
    const originalBlockIds = new Set();
    tableData.contentGroups.forEach(group => {
      originalBlockIds.add(group.id);
    });

// 现在直接从参数中获取操作类型，不需要再显示操作类型选择对话框
    // isAddRow为true表示添加行，为false表示添加列
    let insertPosition, targetIndex;

// 选择插入位置
    const positionOptions = isAddRow ? 
      ["最顶部", "最底部", "指定行之后"] : 
      ["最左侧", "最右侧", "指定列之后"];
    
    const positionResult = await DialogUtils.createCustomDialog(
      "插入位置", 
      `请选择${isAddRow ? "行" : "列"}的插入位置`, 
      positionOptions
    );

if (positionResult === null) {
      new Notice("操作已取消", 3000);
      return;
    }

// 根据选择的位置确定插入索引
    if (positionResult === 0) {
      // 在顶部/左侧
      insertPosition = 'top';
      targetIndex = 0;
    } else if (positionResult === 1) {
      // 在底部/右侧
      insertPosition = 'bottom';
      targetIndex = isAddRow ? tableData.rowCount : tableData.colCount;
    } else if (positionResult === 2) {
      // 在指定行/列之后
      const indexInput = await DialogUtils.createMiniInputDialog(
        `指定${isAddRow ? "行" : "列"}`, 
        `请输入${isAddRow ? "行" : "列"}号（从1开始）`, 
        "1"
      );
      
      if (indexInput == null) {
        new Notice("操作已取消", 3000);
        return;
      }
      
      const index = parseInt(indexInput);
      const maxIndex = isAddRow ? tableData.rowCount : tableData.colCount;
      
      if (isNaN(index) || index < 1 || index > maxIndex) {
        new Notice(`请输入1到${maxIndex}之间的数字`, 3000);
        return;
      }
      
      insertPosition = 'after';
      targetIndex = index;
    }

// 提示用户框选需要添加的区块
    let newBlocks = [];
    let confirmed = false;
    
    while (!confirmed) {
      new Notice(`请框选需要添加的区块\n剩余时间：3秒`);
      await new Promise(r => setTimeout(r, 3000));

// 获取选中的新区块元素
      const newlySelected = ea.getViewSelectedElements();
      
      // 处理区块
      const elementMap = new Map();
      newlySelected.forEach(el => {
        const key = el.groupIds?.[0] || el.id;
        if (!elementMap.has(key)) elementMap.set(key, []);
        elementMap.get(key).push(el);
      });

newBlocks = Array.from(elementMap.values())
        .map(elements => ({
          elements,
          bbox: computeBoundingBox(elements)
        }))
        .filter(block => block.elements.length > 0);

// 显示确认对话框
      const confirmResult = await DialogUtils.createCustomDialog(
        "选择确认", 
        `已选择 ${newBlocks.length} 个区块`, 
        ["取消操作", "重新框选", "确认选择"]
      );
      
      if (confirmResult === 0 || confirmResult === null) {
        new Notice("操作已取消", 3000);
        return;
      } else if (confirmResult === 2) {
        confirmed = true;
      }
    }

if (newBlocks.length === 0) {
      new Notice("未选择任何区块", 3000);
      return;
    }

// 准备原始表格数据以重新构建
    const api = ea.getExcalidrawAPI();
    const spacing = 6;
    
    // 从原始表格中提取所有区块并按行列组织
    const blocksByRowCol = [];
    for (let i = 0; i < tableData.rowCount; i++) {
      blocksByRowCol[i] = [];
      for (let j = 0; j < tableData.colCount; j++) {
        blocksByRowCol[i][j] = null;
      }
    }
    
    // 填充原始区块数据
    tableData.contentGroups.forEach(group => {
      if (group.cell) {
        blocksByRowCol[group.cell.row][group.cell.col] = {
          elements: group.elements,
          bbox: group.bbox
        };
      }
    });

// 根据操作类型和位置插入新区块
    let updatedBlocksByRowCol;
    
    if (isAddRow) {
      // 添加行
      updatedBlocksByRowCol = insertRow(blocksByRowCol, newBlocks, targetIndex);
    } else {
      // 添加列
      updatedBlocksByRowCol = insertColumn(blocksByRowCol, newBlocks, targetIndex);
    }

// 将二维数组转换为功能1所需的列数组格式
    const updatedColumns = [];
    const maxRows = updatedBlocksByRowCol.length;
    const maxCols = updatedBlocksByRowCol[0].length;
    
    for (let col = 0; col < maxCols; col++) {
      const colBlocks = [];
      let maxWidth = 0;
      
      for (let row = 0; row < maxRows; row++) {
        // 保留位置信息，即使单元格为空
        colBlocks.push(updatedBlocksByRowCol[row][col]);
        if (updatedBlocksByRowCol[row][col]) {
          maxWidth = Math.max(maxWidth, updatedBlocksByRowCol[row][col].bbox.width);
        }
      }
      
      updatedColumns.push({
        blocks: colBlocks.filter(block => block !== null), // 但仍只保留非空块用于计算宽度
        width: maxWidth,
        fullBlocks: colBlocks // 保存完整的区块列表，包括null值
      });
    }

// 计算新表格的布局（参考功能1）
    const originPoint = { 
      x: tableData.originPoint.x, 
      y: tableData.originPoint.y 
    };
    
    // 动态计算行高 - 修改这部分以考虑所有行
    const rows = Array.from({ length: maxRows }, (_, rowIndex) => {
      // 查找所有列中当前行的最大高度
      let maxHeight = 0;
      for (let col = 0; col < maxCols; col++) {
        if (updatedBlocksByRowCol[rowIndex][col]) {
          maxHeight = Math.max(maxHeight, updatedBlocksByRowCol[rowIndex][col].bbox.height);
        }
      }
      return {
        height: maxHeight + (rowIndex < maxRows - 1 ? spacing : 0)
      };
    });

// 用于记录新表格的所有元素
    const newTableElements = [];

// 调整元素布局 - 修改这部分以正确处理空单元格
    let currentX = originPoint.x;
    for (let col = 0; col < maxCols; col++) {
      let currentY = originPoint.y;
      const colWidth = updatedColumns[col].width;
      
      for (let row = 0; row < maxRows; row++) {
        const block = updatedBlocksByRowCol[row][col];
        
        // 如果当前单元格有区块，则移动它到正确位置
        if (block) {
          const offsetX = currentX - block.bbox.topX;
          const offsetY = currentY - block.bbox.topY;
          block.elements.forEach(el => {
            el.x += offsetX;
            el.y += offsetY;
            newTableElements.push(el);
          });
        }
        
        // 无论单元格是否为空，都移动到下一行位置
        currentY += rows[row].height;
      }
      
        // 移动到下一列位置
        currentX += colWidth + spacing;
      }
    
    // 绘制分隔线
    const totalWidth = updatedColumns.reduce((sum, c) => sum + c.width, 0) + 
                      (updatedColumns.length - 1) * spacing;
    const totalHeight = rows.reduce((sum, r) => sum + r.height, 0);

// 绘制列分隔线
    updatedColumns.slice(0, -1).reduce((acc, col, i) => {
      const x = acc + col.width + spacing / 2;
      ea.style.strokeColor = "#000000";
      ea.style.roughness = 0;
      const lineId = ea.addLine([
        [x, originPoint.y - 3],
        [x, originPoint.y + totalHeight + 3]
      ]);
      const line = ea.getElement(lineId);
      separatorLines.push(line);
      newTableElements.push(line);
      return acc + col.width + spacing;
    }, originPoint.x);

// 计算包围框
    const box = computeBoundingBox(newTableElements);
    
    // 添加0 padding的基础包围框
    if (newTableElements.length > 0) {
      ea.style.strokeColor = "black";
      ea.style.roughness = 0;
      const padding = 0;
      
      const rectId = ea.addRect(
        box.topX - padding,
        box.topY - padding,
        box.width + padding * 2,
        box.height + padding * 2
      );
      const rect = ea.getElement(rectId);
      newTableElements.push(rect);
    }
    
    // 删除原表格
    ea.deleteViewElements(selectedElements);
    
    // 添加新表格到视图
    ea.copyViewElementsToEAforEditing(newTableElements);
    await ea.addElementsToView(false, false, true);
    
    // 询问是否添加第一行/第一列色块
    const highlightResult = await DialogUtils.createCustomDialog(
      "添加表头高亮",
      "请选择表头的位置",
      ["取消", "第一行", "第一列"]
    );
    
    const highlightElements = [];
    
    if (highlightResult === 1 || highlightResult === 2) {
      // 计算表格单元格位置
      const cells = [];
      let y = originPoint.y;
      
      for (let row = 0; row < maxRows; row++) {
        let x = originPoint.x;
        const rowHeight = rows[row].height - (row < maxRows - 1 ? spacing : 0);
        
        for (let col = 0; col < maxCols; col++) {
          const colWidth = updatedColumns[col].width;
          
          cells.push({
            row,
            col,
            x,
            y,
            width: colWidth,
            height: rowHeight
          });
          
          x += colWidth + spacing;
        }
        
        y += rows[row].height;
      }
      
      // 颜色设置对话框函数
      async function getHeaderBackgroundColor() {
        // 弹出颜色设置对话框
        const colorInput = await DialogUtils.createMiniInputDialog(
          "设置表头颜色",
          "请输入十六进制颜色代码",
          "a5d8ff"
        );
        
        // 验证颜色输入并格式化
        if (colorInput) {
          // 移除可能的空格并确保颜色格式正确
          const trimmedColor = colorInput.trim();
          // 如果没有#前缀，添加#
          const formattedColor = trimmedColor.startsWith('#') ? trimmedColor : `#${trimmedColor}`;
          // 简单验证是否为有效的十六进制颜色格式
          if (/^#[0-9A-Fa-f]{6}$/.test(formattedColor) || /^#[0-9A-Fa-f]{3}$/.test(formattedColor)) {
            return formattedColor;
          }
        }
        // 默认颜色
        return "#a5d8ff";
      }
      
      // 获取用户设置的背景颜色
      const bgColor = await getHeaderBackgroundColor();
      
      // 设置表头高亮矩形样式
      ea.style.strokeColor = "transparent";
      ea.style.backgroundColor = bgColor;
      ea.style.fillStyle = 'solid';
      ea.style.roughness = 0;
      ea.style.opacity = 100;
      
      // 添加第一行色块
      if (highlightResult === 1) {
        for (let col = 0; col < maxCols; col++) {
          const cell = cells.find(c => c.row === 0 && c.col === col);
          if (cell) {
            const rectId = ea.addRect(
              cell.x - 3,
              cell.y - 3,
              cell.width + 6,
              cell.height + 6
            );
            const rect = ea.getElement(rectId);
            highlightElements.push(rect);
          }
        }
      }
      // 添加第一列色块
      else if (highlightResult === 2) {
        for (let row = 0; row < maxRows; row++) {
          const cell = cells.find(c => c.row === row && c.col === 0);
          if (cell) {
            const rectId = ea.addRect(
              cell.x - 3,
              cell.y - 3,
              cell.width + 6,
              cell.height + 6
            );
            const rect = ea.getElement(rectId);
            highlightElements.push(rect);
          }
        }
      }
      
      // 将蓝色背景矩形添加到视图并置于底层
      if (highlightElements.length > 0) {
        ea.copyViewElementsToEAforEditing(highlightElements);
        ea.addElementsToView(false, false, false);
      }
    }
    
    // 将表格元素和蓝色背景矩形合并到一个分组
    if (newTableElements.length > 0 || highlightElements.length > 0) {
      const allGroupElements = [...newTableElements, ...highlightElements];
      const elementIds = allGroupElements.map(el => el.id);
      
      ea.copyViewElementsToEAforEditing(allGroupElements);
      ea.addToGroup(elementIds);
      
      await ea.addElementsToView(false, true, true);
    }
    
    new Notice("表格编辑成功！", 2000);
  } catch (err) {
    console.error("编辑表格出错:", err);
    new Notice(`编辑表格出错: ${err.message}`, 3000);
  }
}

// 解析表格结构（静默模式，不显示错误提示）
async function parseTableStructureSilent(selectedElements) {
  try {
    // 1. 识别表格框架元素（矩形框）
    const frame = selectedElements.find(el => 
      el.type === "rectangle" && 
      !el.groupIds?.length &&
      el.strokeColor !== "transparent"
    );
    
    if (!frame) {
      // 静默模式：不显示错误提示
      return null;
    }
    
    // 2. 识别表格分隔线
    const tableLines = selectedElements.filter(el => 
      el.type === "line" && 
      !el.groupIds?.length &&
      el.strokeColor !== "transparent" &&
      el.strokeWidth > 0.5
    );
    
    if (tableLines.length < 2) {
      // 静默模式：不显示错误提示
      return null;
    }
    
    // 3. 识别单元格内容
    const cellContents = selectedElements.filter(el => 
      el.id !== frame.id && 
      !tableLines.some(line => line.id === el.id) &&
      (el.groupIds?.length || 
       el.type === "text" || 
       el.type === "rectangle" || 
       el.type === "diamond" || 
       el.type === "ellipse")
    );
    
    // 4. 组织分组元素
    const groupedElements = new Map();
    const contentGroups = [];
    
    // 先添加分组元素
    cellContents.forEach(el => {
      if (el.groupIds?.length) {
        const groupId = el.groupIds[0];
        if (!groupedElements.has(groupId)) {
          groupedElements.set(groupId, []);
        }
        groupedElements.get(groupId).push(el);
      }
    });
    
    // 创建分组对象
    groupedElements.forEach((elements, groupId) => {
      contentGroups.push({
        id: groupId,
        elements: elements,
        isGroup: true
      });
    });
    
    // 添加未分组的单个元素
    cellContents.forEach(el => {
      if (!el.groupIds?.length && !groupedElements.has(el.id)) {
        contentGroups.push({
          id: el.id,
          elements: [el],
          isGroup: false
        });
      }
    });
    
    // 5. 计算分组/元素的边界框
    contentGroups.forEach(group => {
      group.bbox = computeBoundingBox(group.elements);
    });
    
    // 6. 分离水平线和垂直线
    const horizontalLines = [];
    const verticalLines = [];
    
    tableLines.forEach(line => {
      const [p1, p2] = line.points;
      const isHorizontal = Math.abs(p1[1] - p2[1]) < 1;
      
      if (isHorizontal) {
        horizontalLines.push({ 
          y: line.y, 
          x1: Math.min(line.x, line.x + p2[0]), 
          x2: Math.max(line.x, line.x + p2[0]),
          element: line
        });
      } else {
        verticalLines.push({ 
          x: line.x, 
          y1: Math.min(line.y, line.y + p2[1]), 
          y2: Math.max(line.y, line.y + p2[1]),
          element: line
        });
      }
    });
    
    // 7. 按位置排序线
    horizontalLines.sort((a, b) => a.y - b.y);
    verticalLines.sort((a, b) => a.x - b.x);
    
    // 8. 添加表格边界线
    horizontalLines.unshift({ 
      y: frame.y, 
      x1: frame.x, 
      x2: frame.x + frame.width 
    });
    
    horizontalLines.push({ 
      y: frame.y + frame.height, 
      x1: frame.x, 
      x2: frame.x + frame.width 
    });
    
    verticalLines.unshift({ 
      x: frame.x, 
      y1: frame.y, 
      y2: frame.y + frame.height 
    });
    
    verticalLines.push({ 
      x: frame.x + frame.width, 
      y1: frame.y, 
      y2: frame.y + frame.height 
    });
    
    // 9. 计算单元格
    const cells = [];
    for (let row = 0; row < horizontalLines.length - 1; row++) {
      for (let col = 0; col < verticalLines.length - 1; col++) {
        const cellX = verticalLines[col].x;
        const cellY = horizontalLines[row].y;
        const cellWidth = verticalLines[col + 1].x - cellX;
        const cellHeight = horizontalLines[row + 1].y - cellY;
        
        cells.push({
          row,
          col,
          x: cellX,
          y: cellY,
          width: cellWidth,
          height: cellHeight
        });
      }
    }
    
    // 10. 关联内容组和单元格
    contentGroups.forEach(group => {
      const centerX = group.bbox.x + group.bbox.width / 2;
      const centerY = group.bbox.y + group.bbox.height / 2;
      
      group.cell = cells.find(cell => 
        centerX >= cell.x && 
        centerX <= cell.x + cell.width &&
        centerY >= cell.y && 
        centerY <= cell.y + cell.height
      );
    });
    
    // 静默模式：不显示"表格解析完成！"提示
    
    // 返回表格数据
    return {
      frame,
      cells,
      contentGroups,
      horizontalLines,
      verticalLines,
      rowCount: horizontalLines.length - 1,
      colCount: verticalLines.length - 1,
      originPoint: { x: frame.x, y: frame.y }
    };
  } catch (err) {
    console.error("表格解析失败:", err);
    // 静默模式：不显示错误提示
    return null;
  }
}

// 解析表格结构（正常模式，显示错误提示）
async function parseTableStructure(selectedElements) {
  try {
    // 1. 识别表格框架元素（矩形框）
    const frame = selectedElements.find(el => 
      el.type === "rectangle" && 
      !el.groupIds?.length &&
      el.strokeColor !== "transparent"
    );
    
    if (!frame) {
      new Notice("未找到表格外框矩形", 3000);
      return null;
    }
    
    // 2. 识别表格分隔线
    const tableLines = selectedElements.filter(el => 
      el.type === "line" && 
      !el.groupIds?.length &&
      el.strokeColor !== "transparent" &&
      el.strokeWidth > 0.5
    );
    
    if (tableLines.length < 2) {
      new Notice("未找到足够的分隔线", 3000);
      return null;
    }
    
    // 3. 识别单元格内容
    const cellContents = selectedElements.filter(el => 
      el.id !== frame.id && 
      !tableLines.some(line => line.id === el.id) &&
      (el.groupIds?.length || 
       el.type === "text" || 
       el.type === "rectangle" || 
       el.type === "diamond" || 
       el.type === "ellipse")
    );
    
    // 4. 组织分组元素
    const groupedElements = new Map();
    const contentGroups = [];
    
    // 先添加分组元素
    cellContents.forEach(el => {
      if (el.groupIds?.length) {
        const groupId = el.groupIds[0];
        if (!groupedElements.has(groupId)) {
          groupedElements.set(groupId, []);
        }
        groupedElements.get(groupId).push(el);
      }
    });
    
    // 创建分组对象
    groupedElements.forEach((elements, groupId) => {
      contentGroups.push({
        id: groupId,
        elements: elements,
        isGroup: true
      });
    });
    
    // 添加未分组的单个元素
    cellContents.forEach(el => {
      if (!el.groupIds?.length && !groupedElements.has(el.id)) {
        contentGroups.push({
          id: el.id,
          elements: [el],
          isGroup: false
        });
      }
    });
    
    // 5. 计算分组/元素的边界框
    contentGroups.forEach(group => {
      group.bbox = computeBoundingBox(group.elements);
    });
    
    // 6. 分离水平线和垂直线
    const horizontalLines = [];
    const verticalLines = [];
    
    tableLines.forEach(line => {
      const [p1, p2] = line.points;
      const isHorizontal = Math.abs(p1[1] - p2[1]) < 1;
      
      if (isHorizontal) {
        horizontalLines.push({ 
          y: line.y, 
          x1: Math.min(line.x, line.x + p2[0]), 
          x2: Math.max(line.x, line.x + p2[0]),
          element: line
        });
      } else {
        verticalLines.push({ 
          x: line.x, 
          y1: Math.min(line.y, line.y + p2[1]), 
          y2: Math.max(line.y, line.y + p2[1]),
          element: line
        });
      }
    });
    
    // 7. 按位置排序线
    horizontalLines.sort((a, b) => a.y - b.y);
    verticalLines.sort((a, b) => a.x - b.x);
    
    // 8. 添加表格边界线
    horizontalLines.unshift({ 
      y: frame.y, 
      x1: frame.x, 
      x2: frame.x + frame.width 
    });
    
    horizontalLines.push({ 
      y: frame.y + frame.height, 
      x1: frame.x, 
      x2: frame.x + frame.width 
    });
    
    verticalLines.unshift({ 
      x: frame.x, 
      y1: frame.y, 
      y2: frame.y + frame.height 
    });
    
    verticalLines.push({ 
      x: frame.x + frame.width, 
      y1: frame.y, 
      y2: frame.y + frame.height 
    });
    
    // 9. 计算单元格
    const cells = [];
    for (let row = 0; row < horizontalLines.length - 1; row++) {
      for (let col = 0; col < verticalLines.length - 1; col++) {
        const cellX = verticalLines[col].x;
        const cellY = horizontalLines[row].y;
        const cellWidth = verticalLines[col + 1].x - cellX;
        const cellHeight = horizontalLines[row + 1].y - cellY;
        
        cells.push({
          row,
          col,
          x: cellX,
          y: cellY,
          width: cellWidth,
          height: cellHeight
        });
      }
    }
    
    // 10. 关联内容组和单元格
    contentGroups.forEach(group => {
      const centerX = group.bbox.x + group.bbox.width / 2;
      const centerY = group.bbox.y + group.bbox.height / 2;
      
      group.cell = cells.find(cell => 
        centerX >= cell.x && 
        centerX <= cell.x + cell.width &&
        centerY >= cell.y && 
        centerY <= cell.y + cell.height
      );
    });
    
    new Notice("表格解析完成！", 3000);
    
    // 返回表格数据
    return {
      frame,
      cells,
      contentGroups,
      horizontalLines,
      verticalLines,
      rowCount: horizontalLines.length - 1,
      colCount: verticalLines.length - 1,
      originPoint: { x: frame.x, y: frame.y }
    };
  } catch (err) {
    console.error("表格解析失败:", err);
    new Notice(`表格解析失败: ${err.message}`, 5000);
    return null;
  }
}

// 插入行 - 修复版本
function insertRow(blocksByRowCol, newBlocks, targetIndex) {
  // 创建深拷贝以避免修改原始数据
  const newBlocksArray = JSON.parse(JSON.stringify(blocksByRowCol));
  // 创建与原表格宽度相匹配的空行
  const emptyRow = new Array(newBlocksArray[0].length).fill(null);
  
  // 在指定索引处插入新行
  newBlocksArray.splice(targetIndex, 0, emptyRow);
  
  // 确保新区块仅添加到新插入的行中，不影响其他行
  newBlocks.forEach((block, index) => {
    // 只在新插入的行中设置区块，避免覆盖其他行的内容
    if (index < newBlocksArray[targetIndex].length) {
      // 确保只修改新插入的行中的null值，不覆盖其他行的内容
      newBlocksArray[targetIndex][index] = block;
    }
  });
  
  return newBlocksArray;
}

// 插入列
function insertColumn(blocksByRowCol, newBlocks, targetIndex) {
  const newBlocksArray = JSON.parse(JSON.stringify(blocksByRowCol));
  
  // 在每一行插入新列
  newBlocksArray.forEach(row => {
    row.splice(targetIndex, 0, null);
  });
  
  // 填充新列的数据
  newBlocks.forEach((block, index) => {
    if (index < newBlocksArray.length) {
      newBlocksArray[index][targetIndex] = block;
    }
  });
  
  return newBlocksArray;
}

// 计算元素组的边界框
function computeBoundingBox(elements) {
  if (!elements || elements.length === 0) return { x: 0, y: 0, width: 0, height: 0, topX: 0, topY: 0 };
  
  let minX = Infinity;
  let minY = Infinity;
  let maxX = -Infinity;
  let maxY = -Infinity;
  
  elements.forEach(el => {
    if (el.type === "line") {
      const points = el.points;
      points.forEach(([x, y]) => {
        const absX = el.x + x;
        const absY = el.y + y;
        minX = Math.min(minX, absX);
        minY = Math.min(minY, absY);
        maxX = Math.max(maxX, absX);
        maxY = Math.max(maxY, absY);
      });
    } else if (el.type === "text") {
      minX = Math.min(minX, el.x);
      minY = Math.min(minY, el.y);
      maxX = Math.max(maxX, el.x + el.width);
      maxY = Math.max(maxY, el.y + el.height);
    } else {
      minX = Math.min(minX, el.x);
      minY = Math.min(minY, el.y);
      maxX = Math.max(maxX, el.x + el.width);
      maxY = Math.max(maxY, el.y + el.height);
    }
  });
  
  return {
    x: minX,
    y: minY,
    width: maxX - minX,
    height: maxY - minY,
    topX: minX,
    topY: minY
  };
}

// 清理函数，用于脚本执行结束后清除内存占用与缓存
function cleanupResources() {
    try {
        console.log("Grid Selected Text-CellSpotlight: 开始清理资源");
        
        // 清理临时变量
        if (typeof window !== 'undefined') {
            // 释放可能的模块缓存
            if (window.moduleCache && typeof window.moduleCache === 'object') {
                for (const key in window.moduleCache) {
                    if (window.moduleCache.hasOwnProperty(key)) {
                        delete window.moduleCache[key];
                    }
                }
            }
        }
        
        // 尝试垃圾回收
        if (typeof globalThis.gc === 'function') {
            try {
                globalThis.gc();
                console.log("Grid Selected Text-CellSpotlight: 已执行垃圾回收");
            } catch (e) {
                console.log("Grid Selected Text-CellSpotlight: 自动GC不可用");
            }
        }
        
        console.log("Grid Selected Text-CellSpotlight: 资源清理完成");
    } catch (e) {
        console.error("Grid Selected Text-CellSpotlight: 清理资源时出错:", e);
    }
}

wk/obsidian

About

Releases

Contributors

Activities