nolo-cli 0.1.23 → 0.1.29

package/create/editor/utils/pdfToSlate.ts

@@ -0,0 +1,706 @@
+import * as pdfjsLib from "pdfjs-dist";
+
+// 设置 pdf.js worker 路径（根据你的项目配置调整）
+pdfjsLib.GlobalWorkerOptions.workerSrc = "/public/assets/pdf.worker.mjs";
+
+// Slate.js 节点的基本类型定义（与 DOCX 代码一致）
+interface SlateNode {
+  type: string;
+  children: Array<
+    | { text: string; bold?: boolean; italic?: boolean; underline?: boolean }
+    | SlateNode
+  >;
+  ordered?: boolean; // 用于列表
+  url?: string; // 用于超链接和图片
+  alt?: string; // 用于图片
+  header?: boolean; // 用于表格单元格
+}
+
+// 辅助接口：存储书签信息
+interface OutlineItem {
+  title: string;
+  level: number; // 书签嵌套级别，映射到标题级别
+  pageNumber: number | null; // 跳转目标页面号
+  dest: any; // 跳转目标详细信息（可能包含位置）
+}
+
+// 辅助接口：存储超链接注解信息
+interface LinkAnnotation {
+  url: string;
+  rect: number[]; // 注解的矩形区域 [x1, y1, x2, y2]
+}
+
+// 转换 PDF 内容为 Slate.js 格式
+export const convertPdfToSlate = async (file: File): Promise<SlateNode[]> => {
+  try {
+    // 读取文件为 ArrayBuffer
+    const arrayBuffer = await file.arrayBuffer();
+
+    // 使用 pdf.js 加载 PDF
+    const pdf = await pdfjsLib.getDocument({ data: arrayBuffer }).promise;
+
+    // 获取页面数量
+    const numPages = pdf.numPages;
+    const slateNodes: SlateNode[] = [];
+    let listStack: { node: SlateNode; level: number }[] = []; // 用于处理可能的列表结构
+
+    // 用于估计行间距分布和字体大小分布
+    let lineHeightDiffs: number[] = [];
+    let fontSizes: number[] = [];
+    let avgLineHeight = 0;
+    let baseFontSize = 0;
+
+    // 获取文档大纲（书签）
+    const outline = await pdf.getOutline();
+    const outlineItems: OutlineItem[] = [];
+    if (outline) {
+      // 递归处理书签大纲，提取标题和级别
+      const processOutline = async (items: any[], parentLevel: number = 0) => {
+        for (const item of items) {
+          const title = item.title || "";
+          const level = parentLevel + 1; // 书签嵌套级别，从 1 开始
+          let pageNumber = null;
+          if (item.dest && typeof item.dest === "string") {
+            const destRef = await pdf.getDestination(item.dest);
+            if (
+              destRef &&
+              destRef.length > 0 &&
+              typeof destRef[0] === "number"
+            ) {
+              pageNumber = (await pdf.getPageIndex(destRef[0])) + 1; // 页面号从 1 开始
+            }
+          } else if (
+            item.dest &&
+            item.dest.length > 0 &&
+            typeof item.dest[0] === "number"
+          ) {
+            pageNumber = (await pdf.getPageIndex(item.dest[0])) + 1;
+          }
+          outlineItems.push({ title, level, pageNumber, dest: item.dest });
+          if (item.items && item.items.length > 0) {
+            await processOutline(item.items, level);
+          }
+        }
+      };
+      await processOutline(outline);
+    }
+
+    // 第一步：遍历所有页面，收集行间距和字体大小数据，但排除最后 1-2 页的字体大小
+    for (let i = 1; i <= numPages; i++) {
+      const page = await pdf.getPage(i);
+      const textContent = await page.getTextContent();
+      let previousY = 0;
+
+      textContent.items.forEach((item, index) => {
+        if ("transform" in item) {
+          const currentY = item.transform[5];
+          const diff = Math.abs(currentY - previousY);
+          if (index > 0 && diff > 0 && diff < 50) {
+            // 假设行间距小于 50，排除异常值
+            lineHeightDiffs.push(diff);
+          }
+          previousY = currentY;
+        }
+        if ("fontName" in item) {
+          const fontSize = extractFontSize(item.fontName, item);
+          // 仅将前 numPages-2 页的字体大小计入统计，避免最后 1-2 页的小字体影响基准值
+          // 如果总页数少于 3 页，则全部计入
+          if (numPages <= 3 || i <= numPages - 2) {
+            fontSizes.push(fontSize);
+          }
+        }
+      });
+    }
+
+    // 计算行间距基准：使用中位数，避免异常值干扰
+    lineHeightDiffs.sort((a, b) => a - b);
+    avgLineHeight =
+      lineHeightDiffs.length > 0
+        ? lineHeightDiffs[Math.floor(lineHeightDiffs.length / 2)]
+        : 12; // 默认行高为 12
+
+    // 计算正文字体大小基准：使用频率最高的字体大小（近似方法）
+    baseFontSize = calculateBaseFontSize(fontSizes);
+
+    // 第二步：处理内容并转换为 Slate.js 节点
+    let titleCount = 0; // 统计标题数量
+    let totalParagraphs = 0; // 统计总段落数量
+
+    for (let i = 1; i <= numPages; i++) {
+      const page = await pdf.getPage(i);
+      const textContent = await page.getTextContent();
+      const annotations = await page.getAnnotations();
+
+      // 获取当前页面的书签标题
+      const pageOutlineItems = outlineItems.filter(
+        (item) => item.pageNumber === i
+      );
+
+      // 获取当前页面的超链接注解
+      const pageLinks: LinkAnnotation[] = annotations
+        .filter((annot) => annot.subtype === "Link" && annot.url)
+        .map((annot) => ({
+          url: annot.url,
+          rect: annot.rect, // 矩形区域 [x1, y1, x2, y2]
+        }));
+
+      // 用于存储当前行的文本和样式信息
+      let currentLineText = "";
+      let currentLineStyles: Array<{
+        fontSize: number;
+        bold: boolean;
+        italic: boolean;
+        text: string;
+        x: number;
+        y: number;
+      }> = [];
+      let currentParagraphText = "";
+      let currentParagraphStyles: Array<{
+        fontSize: number;
+        bold: boolean;
+        italic: boolean;
+        text: string;
+        x: number;
+        y: number;
+      }> = [];
+      let previousY = 0; // 用于判断行间距，推断段落分隔
+      let previousX = 0; // 用于判断水平位置，推断列表
+
+      // 将文本内容按行和段落分组，判断标题
+      textContent.items.forEach((item, index) => {
+        if ("str" in item && item.str.trim()) {
+          const fontSize = item.fontName
+            ? extractFontSize(item.fontName, item)
+            : 12;
+          const currentY = item.transform ? item.transform[5] : 0; // Y 坐标，用于判断行间距
+          const currentX = item.transform ? item.transform[4] : 0; // X 坐标，用于判断缩进或列表
+          const isBold = item.fontName?.toLowerCase().includes("bold");
+          const isItalic = item.fontName?.toLowerCase().includes("italic");
+
+          // 判断是否为新行：基于行间距（普通换行）
+          const isNewLine =
+            index > 0 && Math.abs(currentY - previousY) > avgLineHeight * 0.5;
+
+          // 判断是否为新段落：基于明显更大的行间距（段落间距）
+          const isNewParagraph =
+            index > 0 && Math.abs(currentY - previousY) > avgLineHeight * 1.8; // 1.8 倍作为段落分隔阈值
+
+          // 如果是新行，处理前一行的内容
+          if (isNewLine && currentLineText.trim()) {
+            // 将当前行添加到段落中，但不触发新段落
+            currentParagraphText += currentLineText + "\n";
+            currentParagraphStyles.push(...currentLineStyles);
+            // 重置当前行
+            currentLineText = "";
+            currentLineStyles = [];
+          }
+
+          // 如果是新段落，处理前一段落的内容
+          if (isNewParagraph && currentParagraphText.trim()) {
+            totalParagraphs++;
+            // 判断是否为标题：整行字体大小都与基准值不同（都大于或都小于），或整行加粗，或匹配书签
+            const isTitleCandidateBySize = isLineTitleBySize(
+              currentParagraphStyles,
+              baseFontSize
+            );
+            const isTitleCandidateByBold = isLineTitleByBold(
+              currentParagraphStyles
+            );
+            const titleRatio = titleCount / (totalParagraphs || 1);
+            // 标题长度限制：少于 15 个单词或 100 个字符
+            const isTitleLengthValid =
+              isTitleLengthAcceptable(currentParagraphText);
+            // 检查是否匹配书签标题（优先级最高）
+            const matchedOutlineItem = matchOutlineItem(
+              currentParagraphText,
+              pageOutlineItems
+            );
+            const isTitle =
+              (matchedOutlineItem ||
+                isTitleCandidateByBold ||
+                (isTitleCandidateBySize && titleRatio < 0.3)) &&
+              isTitleLengthValid; // 书签优先，或整行加粗，或字体大小条件且比例限制
+            // 推断是否为列表项：基于 X 坐标缩进和文本开头是否为编号或符号
+            const isListItem =
+              index > 0 &&
+              Math.abs(currentX - previousX) > 5 &&
+              (currentParagraphText.trim().match(/^[0-9]+[\.\)]/) ||
+                currentParagraphText.trim().match(/^[-•◦]/));
+            let nodeType = "paragraph";
+            let headingLevel = 0;
+
+            if (isTitle) {
+              titleCount++;
+              const titleFontSize =
+                currentParagraphStyles[0]?.fontSize || baseFontSize;
+              if (matchedOutlineItem) {
+                // 如果匹配书签，使用书签级别
+                headingLevel = Math.min(matchedOutlineItem.level, 6);
+              } else if (titleFontSize > baseFontSize) {
+                // 否则基于字体大小差值计算级别
+                headingLevel = Math.min(
+                  Math.floor((titleFontSize - baseFontSize) / 2) + 1,
+                  6
+                ); // 标题级别 1-6，h1 到 h6
+              } else {
+                headingLevel = Math.min(
+                  Math.floor((baseFontSize - titleFontSize) / 2) + 3,
+                  6
+                ); // 小于基准值，级别从 h3 开始
+              }
+              nodeType = `heading-${toLowerCaseNumber(headingLevel.toString())}`;
+            } else if (isListItem) {
+              nodeType = "list-item";
+            }
+
+            // 构建 Slate.js 节点，处理行内样式和超链接
+            const itemNode = buildSlateNodeWithLinks(
+              nodeType,
+              currentParagraphText,
+              currentParagraphStyles,
+              pageLinks
+            );
+
+            if (isListItem && !isTitle) {
+              const listLevel = Math.floor((currentX - previousX) / 20); // 粗略计算列表缩进级别
+              const isOrdered =
+                currentParagraphText.trim().match(/^[0-9]+[\.\)]/) !== null;
+              handleListItem(
+                itemNode,
+                listStack,
+                slateNodes,
+                listLevel,
+                isOrdered
+              );
+            } else {
+              slateNodes.push(itemNode);
+              listStack = []; // 重置列表栈
+            }
+
+            // 重置段落
+            currentParagraphText = "";
+            currentParagraphStyles = [];
+          }
+
+          // 累积当前文本到当前行
+          currentLineText += item.str;
+          currentLineStyles.push({
+            fontSize,
+            bold: isBold,
+            italic: isItalic,
+            text: item.str,
+            x: currentX,
+            y: currentY,
+          });
+
+          previousY = currentY;
+          previousX = currentX;
+        }
+      });
+
+      // 处理剩余行和段落
+      if (currentLineText.trim()) {
+        currentParagraphText += currentLineText + "\n";
+        currentParagraphStyles.push(...currentLineStyles);
+      }
+
+      if (currentParagraphText.trim()) {
+        totalParagraphs++;
+        const isTitleCandidateBySize = isLineTitleBySize(
+          currentParagraphStyles,
+          baseFontSize
+        );
+        const isTitleCandidateByBold = isLineTitleByBold(
+          currentParagraphStyles
+        );
+        const titleRatio = titleCount / (totalParagraphs || 1);
+        const isTitleLengthValid =
+          isTitleLengthAcceptable(currentParagraphText);
+        const matchedOutlineItem = matchOutlineItem(
+          currentParagraphText,
+          pageOutlineItems
+        );
+        const isTitle =
+          (matchedOutlineItem ||
+            isTitleCandidateByBold ||
+            (isTitleCandidateBySize && titleRatio < 0.3)) &&
+          isTitleLengthValid;
+        const isListItem =
+          Math.abs(previousX) > 5 &&
+          (currentParagraphText.trim().match(/^[0-9]+[\.\)]/) ||
+            currentParagraphText.trim().match(/^[-•◦]/));
+        let nodeType = "paragraph";
+        let headingLevel = 0;
+
+        if (isTitle) {
+          titleCount++;
+          const titleFontSize =
+            currentParagraphStyles[0]?.fontSize || baseFontSize;
+          if (matchedOutlineItem) {
+            headingLevel = Math.min(matchedOutlineItem.level, 6);
+          } else if (titleFontSize > baseFontSize) {
+            headingLevel = Math.min(
+              Math.floor((titleFontSize - baseFontSize) / 2) + 1,
+              6
+            );
+          } else {
+            headingLevel = Math.min(
+              Math.floor((baseFontSize - titleFontSize) / 2) + 3,
+              6
+            );
+          }
+          nodeType = `heading-${toLowerCaseNumber(headingLevel.toString())}`;
+        } else if (isListItem) {
+          nodeType = "list-item";
+        }
+
+        const itemNode = buildSlateNodeWithLinks(
+          nodeType,
+          currentParagraphText,
+          currentParagraphStyles,
+          pageLinks
+        );
+
+        if (isListItem && !isTitle) {
+          const listLevel = Math.floor(previousX / 20);
+          const isOrdered =
+            currentParagraphText.trim().match(/^[0-9]+[\.\)]/) !== null;
+          handleListItem(itemNode, listStack, slateNodes, listLevel, isOrdered);
+        } else {
+          slateNodes.push(itemNode);
+          listStack = [];
+        }
+      }
+
+      // 处理图片占位符（通过注解或其他方式检测图片位置）
+      // 由于 PDF.js 不直接提供图片内容，我们通过注解或其他间接方式添加占位符
+      // 这里简化为在每页末尾检查是否有未处理的图片相关注解，实际中可以结合更复杂的位置匹配
+      const imageAnnotations = annotations.filter(
+        (annot) => annot.subtype === "Widget" || annot.subtype === "Stamp"
+      );
+      if (imageAnnotations.length > 0) {
+        imageAnnotations.forEach(() => {
+          slateNodes.push({
+            type: "image",
+            url: "", // 占位符，无具体图片信息
+            alt: "Image Placeholder",
+            children: [{ text: "" }],
+          });
+        });
+      }
+
+      // 可选：添加分页符节点
+      if (i < numPages) {
+        slateNodes.push({
+          type: "thematic-break",
+          children: [{ text: "" }],
+        });
+      }
+    }
+
+    // 如果没有内容，添加空段落
+    if (slateNodes.length === 0) {
+      slateNodes.push({
+        type: "paragraph",
+        children: [{ text: "（空 PDF 或无有效内容）" }],
+      });
+    }
+
+    return slateNodes;
+  } catch (error) {
+    console.error("转换 PDF 到 Slate.js 格式失败：", error);
+    throw error;
+  }
+};
+
+// 辅助函数：从 fontName 或 item 中提取字体大小（简化为示例）
+function extractFontSize(fontName: string, item: any): number {
+  if (item.transform) {
+    return Math.round(item.transform[0] * 10); // 简化为基于变换矩阵的近似值
+  }
+  return 12; // 默认值
+}
+
+// 辅助函数：计算正文字体大小基准（基于频率最高的字体大小）
+function calculateBaseFontSize(fontSizes: number[]): number {
+  if (fontSizes.length === 0) return 12; // 默认值
+
+  // 简单的频率统计，找到出现次数最多的字体大小
+  const sizeCount: { [key: number]: number } = {};
+  fontSizes.forEach((size) => {
+    sizeCount[size] = (sizeCount[size] || 0) + 1;
+  });
+
+  let maxCount = 0;
+  let baseSize = 12;
+  for (const size in sizeCount) {
+    if (sizeCount[size] > maxCount) {
+      maxCount = sizeCount[size];
+      baseSize = parseFloat(size);
+    }
+  }
+
+  return baseSize;
+}
+
+// 辅助函数：判断是否为标题（基于字体大小，整行字体大小都与基准值不同）
+function isLineTitleBySize(
+  styles: Array<{ fontSize: number; bold: boolean }>,
+  baseFontSize: number
+): boolean {
+  if (styles.length === 0) return false;
+
+  // 检查是否所有文本字体大小都大于基准值
+  const allLarger = styles.every((style) => style.fontSize > baseFontSize + 2); // 差值至少 2
+  // 检查是否所有文本字体大小都小于基准值
+  const allSmaller = styles.every((style) => style.fontSize < baseFontSize - 2); // 差值至少 2
+
+  // 如果都大于或都小于基准值，且差值明显，则认为是标题
+  return allLarger || allSmaller;
+}
+
+// 辅助函数：判断是否为标题（基于加粗，整行字体都加粗）
+function isLineTitleByBold(
+  styles: Array<{ fontSize: number; bold: boolean }>
+): boolean {
+  if (styles.length === 0) return false;
+
+  // 检查是否所有文本都加粗
+  const allBold = styles.every((style) => style.bold);
+
+  return allBold;
+}
+
+// 辅助函数：判断标题长度是否符合要求（不宜过长）
+function isTitleLengthAcceptable(text: string): boolean {
+  const trimmedText = text.trim();
+  const wordCount = trimmedText.split(/\s+/).length;
+  const charCount = trimmedText.length;
+  // 标题长度限制：少于 15 个单词且少于 100 个字符
+  return wordCount < 15 && charCount < 100;
+}
+
+// 辅助函数：匹配书签标题
+function matchOutlineItem(
+  text: string,
+  outlineItems: OutlineItem[]
+): OutlineItem | null {
+  const trimmedText = text.trim().toLowerCase();
+  for (const item of outlineItems) {
+    const outlineTitle = item.title.toLowerCase();
+    // 简单匹配：如果文本包含书签标题或书签标题包含文本，则认为匹配
+    if (
+      trimmedText.includes(outlineTitle) ||
+      outlineTitle.includes(trimmedText)
+    ) {
+      return item;
+    }
+  }
+  return null;
+}
+
+// 辅助函数：构建 Slate.js 节点，处理行内样式和超链接
+function buildSlateNodeWithLinks(
+  type: string,
+  text: string,
+  styles: Array<{
+    fontSize: number;
+    bold: boolean;
+    italic: boolean;
+    text: string;
+    x: number;
+    y: number;
+  }>,
+  links: LinkAnnotation[]
+): SlateNode {
+  // 如果没有样式差异，简化处理
+  const allSameStyle = styles.every(
+    (s) => s.bold === styles[0].bold && s.italic === styles[0].italic
+  );
+  const trimmedText = text.trim();
+
+  if (allSameStyle && styles.length > 0) {
+    // 检查是否有超链接匹配
+    const link = findMatchingLink(styles, links);
+    if (link) {
+      return {
+        type: "link",
+        url: link.url,
+        children: [
+          {
+            text: trimmedText,
+            ...(styles[0].bold && { bold: true }),
+            ...(styles[0].italic && { italic: true }),
+          },
+        ],
+      };
+    }
+    return {
+      type,
+      children: [
+        {
+          text: trimmedText,
+          ...(styles[0].bold && { bold: true }),
+          ...(styles[0].italic && { italic: true }),
+        },
+      ],
+    };
+  }
+
+  // 如果有样式差异，按部分构建 children，并处理超链接
+  const children: Array<
+    { text: string; bold?: boolean; italic?: boolean } | SlateNode
+  > = [];
+  let currentText = "";
+  let currentStyle = styles[0];
+  let startIndex = 0;
+
+  for (let i = 0; i < styles.length; i++) {
+    const style = styles[i];
+    if (
+      i > 0 &&
+      (style.bold !== currentStyle.bold || style.italic !== currentStyle.italic)
+    ) {
+      // 样式变化，处理前一段文本
+      if (currentText) {
+        const subStyles = styles.slice(startIndex, i);
+        const link = findMatchingLink(subStyles, links);
+        if (link) {
+          children.push({
+            type: "link",
+            url: link.url,
+            children: [
+              {
+                text: currentText,
+                ...(currentStyle.bold && { bold: true }),
+                ...(currentStyle.italic && { italic: true }),
+              },
+            ],
+          });
+        } else {
+          children.push({
+            text: currentText,
+            ...(currentStyle.bold && { bold: true }),
+            ...(currentStyle.italic && { italic: true }),
+          });
+        }
+        currentText = "";
+      }
+      startIndex = i;
+      currentStyle = style;
+    }
+    currentText += style.text;
+  }
+
+  // 处理最后一段文本
+  if (currentText) {
+    const subStyles = styles.slice(startIndex);
+    const link = findMatchingLink(subStyles, links);
+    if (link) {
+      children.push({
+        type: "link",
+        url: link.url,
+        children: [
+          {
+            text: currentText,
+            ...(currentStyle.bold && { bold: true }),
+            ...(currentStyle.italic && { italic: true }),
+          },
+        ],
+      });
+    } else {
+      children.push({
+        text: currentText,
+        ...(currentStyle.bold && { bold: true }),
+        ...(currentStyle.italic && { italic: true }),
+      });
+    }
+  }
+
+  return {
+    type,
+    children,
+  };
+}
+
+// 辅助函数：查找匹配的超链接
+function findMatchingLink(
+  styles: Array<{ x: number; y: number }>,
+  links: LinkAnnotation[]
+): LinkAnnotation | null {
+  if (styles.length === 0 || links.length === 0) return null;
+
+  // 简单匹配：检查文本位置是否在某个超链接的矩形区域内
+  // 由于 PDF.js 坐标系可能需要转换，这里仅使用近似匹配
+  const xMin = Math.min(...styles.map((s) => s.x));
+  const xMax = Math.max(...styles.map((s) => s.x));
+  const yMin = Math.min(...styles.map((s) => s.y));
+  const yMax = Math.max(...styles.map((s) => s.y));
+
+  for (const link of links) {
+    const [linkX1, linkY1, linkX2, linkY2] = link.rect;
+    // 检查文本区域是否与链接区域重叠（宽松匹配）
+    if (xMax > linkX1 && xMin < linkX2 && yMax > linkY1 && yMin < linkY2) {
+      return link;
+    }
+  }
+  return null;
+}
+
+// 辅助函数：将数字转换为小写英文形式（1 -> one, 2 -> two, ...）
+function toLowerCaseNumber(num: string): string {
+  const numbers = ["one", "two", "three", "four", "five", "six"];
+  const index = parseInt(num) - 1;
+  return numbers[index] || "one";
+}
+
+// 辅助函数：处理列表项逻辑
+function handleListItem(
+  itemNode: SlateNode,
+  listStack: { node: SlateNode; level: number }[],
+  slateNodes: SlateNode[],
+  listLevel: number,
+  isOrdered: boolean
+) {
+  if (listStack.length === 0) {
+    const newList: SlateNode = {
+      type: "list",
+      ordered: isOrdered,
+      children: [itemNode],
+    };
+    slateNodes.push(newList);
+    listStack.push({ node: newList, level: listLevel });
+  } else if (listStack[listStack.length - 1].level < listLevel) {
+    const newList: SlateNode = {
+      type: "list",
+      ordered: isOrdered,
+      children: [itemNode],
+    };
+    const parentList = listStack[listStack.length - 1].node;
+    const lastListItem = parentList.children[
+      parentList.children.length - 1
+    ] as SlateNode;
+    lastListItem.children.push(newList);
+    listStack.push({ node: newList, level: listLevel });
+  } else if (listStack[listStack.length - 1].level > listLevel) {
+    while (
+      listStack.length > 0 &&
+      listStack[listStack.length - 1].level > listLevel
+    ) {
+      listStack.pop();
+    }
+    if (listStack.length > 0) {
+      listStack[listStack.length - 1].node.children.push(itemNode);
+    } else {
+      const newList: SlateNode = {
+        type: "list",
+        ordered: isOrdered,
+        children: [itemNode],
+      };
+      slateNodes.push(newList);
+      listStack.push({ node: newList, level: listLevel });
+    }
+  } else {
+    listStack[listStack.length - 1].node.children.push(itemNode);
+  }
+}