@mxmweb/aichat 1.1.1 → 1.1.8

package/src/adopters/gientechCommon/slate/converters/deserializers.ts

@@ -0,0 +1,757 @@
+import { marked } from 'marked';
+import type {
+  CustomElement,
+  CustomText,
+  ParagraphElement,
+  HeadingOneElement,
+  HeadingTwoElement,
+  ListElement,
+  ListItemElement,
+  BaseElement,
+  CodeBlockElement,
+  HeadingThreeElement,
+  BlockQuoteElement,
+  TableElement,
+  TableRowElement,
+  TableCellElement,
+} from './slateConverters';
+
+// 新增think类型
+export interface ThinkElement extends BaseElement {
+  type: 'think';
+}
+
+function ensureChildren(elements: CustomElement[]): CustomElement[] {
+  return elements.map(el => {
+    if (!el.children || el.children.length === 0) {
+      return { ...el, children: [{ text: '' }] };
+    }
+    return {
+      ...el,
+      children: el.children.map(child => {
+        if (typeof child === 'object' && 'type' in child) {
+          return ensureChildren([child as CustomElement])[0];
+        }
+        return child;
+      }),
+    };
+  });
+}
+function getContentAfterThinkTag(text: string) {
+  if (text.indexOf('<think>') > -1) {
+    if (text.indexOf('</think>') > -1) {
+      const closedThinkRegex = /<think>([\s\S]*?)<\/think>([\s\S]*)/s;
+      const match = text.match(closedThinkRegex);
+      if (match) {
+        return {
+          thinkContent: match[1],
+          content: match[2],
+          finish: true,
+        };
+      } else {
+        return {
+          thinkContent: '',
+          content: text,
+          finish: true,
+        };
+      }
+    } else {
+      const closedThinkRegex2 = /<think>(.*?)(?=<|\s*$)/s;
+      const match2 = text.match(closedThinkRegex2);
+      return { thinkContent: match2?.[1] || '', content: '' };
+    }
+  } else {
+    return {
+      thinkContent: '',
+      content: text,
+    };
+  }
+}
+export function deserializeMarkdown(markdown: string, respTime?: number): CustomElement[] {
+  // 先全局处理 retrive-tag
+  markdown = markdown.replace(
+    /\[retrive-tag([^\]]*)\]\[([\s\S]*?)\]\[\/retrive-tag\]/g,
+    (match, attrs, inner) => `<retrive-tag${attrs ? ' ' + attrs.trim() : ''}>${inner}</retrive-tag>`
+  );
+
+  // 1. 用正则分割出 <think>...</think> 和普通 markdown 块
+  // const blocks: { type: 'think' | 'markdown', content: string }[] = [];
+  // let lastIndex = 0;
+  // const thinkRegex = /<think>([\s\S]*?)<\/think>/g;
+  // let match;
+  // while ((match = thinkRegex.exec(markdown)) !== null) {
+  //   if (match.index > lastIndex) {
+  //     blocks.push({ type: 'markdown', content: markdown.slice(lastIndex, match.index) });
+  //   }
+  //   blocks.push({ type: 'think', content: match[1] });
+  //   lastIndex = thinkRegex.lastIndex;
+  // }
+  // if (lastIndex < markdown.length) {
+  //   blocks.push({ type: 'markdown', content: markdown.slice(lastIndex) });
+  // }
+  const blocks: { type: 'think' | 'markdown'; content: string; respTime?: number }[] = [];
+  const { thinkContent, content, finish } = getContentAfterThinkTag(markdown || '');
+
+  blocks.push({ type: 'think', content: thinkContent, respTime });
+  blocks.push({ type: 'markdown', content });
+  // 2. 分别处理每个块
+  let results: CustomElement[] = [];
+  let thinkId = 0;
+  // 新增：收集retrive-tag id顺序
+  const retriveTagOrder: string[] = [];
+  const retriveTagSet = new Set<string>();
+  // 包装原有的递归，收集id
+  function collectRetriveTagIds(nodes: any[]) {
+    for (const node of nodes) {
+      if (node && typeof node === 'object') {
+        if (Array.isArray(node)) {
+          collectRetriveTagIds(node);
+        } else {
+          if (node.retrive && node.id && !retriveTagSet.has(node.id)) {
+            retriveTagOrder.push(node.id);
+            retriveTagSet.add(node.id);
+          }
+          if (node.children) collectRetriveTagIds(node.children);
+        }
+      }
+    }
+  }
+  for (const block of blocks) {
+    if (block.type === 'think') {
+      // think 块分行，遇到 retrive-tag 用 DOM 解析
+      const lines = block.content
+        .split(/\n+/)
+        .map(line => line.trim())
+        .filter(Boolean);
+      const children = lines.flatMap(line => {
+        if (/<retrive-tag/i.test(line)) {
+          const div = document.createElement('div');
+          div.innerHTML = line;
+          return deserializeHtmlNode(div, respTime);
+        } else {
+          // 保证类型一致，包装为 ParagraphElement
+          return [{ type: 'paragraph', children: [{ text: line }] } as ParagraphElement];
+        }
+      });
+      // console.log('think AST:', {
+      //   type: 'think',
+      //   children,
+      // });
+      results.push({
+        type: 'think',
+        id: `think-${thinkId++}`,
+        thinkContent,
+        finish,
+        children,
+      } as any);
+    } else {
+      // 其它 markdown 块用 marked 解析
+      marked.setOptions({ gfm: true, breaks: true, pedantic: false });
+      let html = marked(block.content);
+      if (typeof html !== 'string') {
+        html = '';
+      }
+      const div = document.createElement('div');
+      div.innerHTML = html;
+      const part = deserializeHtmlNode(div, respTime);
+      if (part && part.length > 0) {
+        results = results.concat(part);
+      }
+    }
+  }
+  // 收集所有retrive-tag id顺序
+  collectRetriveTagIds(results);
+  // 生成编号映射
+  const retriveTagIndexMap: Record<string, number> = {};
+  retriveTagOrder.forEach((id, idx) => {
+    retriveTagIndexMap[id] = idx + 1;
+  });
+  // 新增：递归给每个retrive-tag节点赋值indexId
+  function assignRetriveTagIndexId(nodes: any[]) {
+    for (const node of nodes) {
+      if (node && typeof node === 'object') {
+        if (Array.isArray(node)) {
+          assignRetriveTagIndexId(node);
+        } else {
+          if (node.retrive && node.id && retriveTagIndexMap[node.id]) {
+            node.indexId = retriveTagIndexMap[node.id];
+          }
+          if (node.children) assignRetriveTagIndexId(node.children);
+        }
+      }
+    }
+  }
+  assignRetriveTagIndexId(results);
+  // 挂载到AST根节点
+  (results as any)._retriveTagIndexMap = retriveTagIndexMap;
+  // 保证返回值始终为非空数组，且所有节点children非空
+  if (!results || results.length === 0) {
+    return [{ type: 'paragraph', children: [{ text: '' }] } as ParagraphElement];
+  }
+  //console.log('deserializeMarkdown 返回 AST:', results);
+  return ensureChildren(results);
+}
+
+function deserializeHtmlNode(node: Node, respTime?: number): CustomElement[] {
+  const elements: CustomElement[] = [];
+
+  const deNodes = (elements: CustomElement[], nodeList: NodeListOf<ChildNode>) => {
+    nodeList.forEach((child: any) => {
+      if (child.nodeType === Node.ELEMENT_NODE) {
+        const el = child as HTMLElement;
+        let result;
+        switch (el.tagName && el.tagName.toLowerCase()) {
+          case 'p': {
+            // 如果 <p> 只包含一个 <think>，则直接提升为 think 节点
+            const onlyChild = el.childNodes.length === 1 ? el.childNodes[0] : null;
+            if (
+              onlyChild &&
+              onlyChild.nodeType === Node.ELEMENT_NODE &&
+              (onlyChild as HTMLElement).tagName.toLowerCase() === 'think'
+            ) {
+              // 直接递归 think，不包 paragraph
+              result = deserializeChildren(el)[0];
+            } else {
+              result = {
+                type: 'paragraph',
+                children: deserializeChildren(el),
+              } as ParagraphElement;
+            }
+            break;
+          }
+          case 'h1':
+            result = {
+              type: 'heading-one',
+              children: deserializeChildren(el),
+            } as HeadingOneElement;
+            break;
+          case 'h2':
+            result = {
+              type: 'heading-two',
+              children: deserializeChildren(el),
+            } as HeadingTwoElement;
+            break;
+          case 'h3':
+            result = {
+              type: 'heading-three',
+              children: deserializeChildren(el),
+            } as HeadingThreeElement;
+            break;
+          case 'ul':
+          case 'ol': {
+            // 递归 deNodes，让 li 的 case 统一处理
+            let listChildren: CustomElement[] = [];
+            deNodes(listChildren, el.childNodes);
+            result = {
+              type: el.tagName.toLowerCase() === 'ul' ? 'bulleted-list' : 'numbered-list',
+              children: listChildren,
+            } as ListElement;
+            break;
+          }
+          case 'li':
+          case 'LI': {
+            // 判断 li 里是否有 block 元素
+            const hasBlock = Array.from(el.childNodes).some(child => {
+              if (child.nodeType !== Node.ELEMENT_NODE) return false;
+              const tag = (child as HTMLElement).tagName?.toUpperCase?.();
+              return tag === 'UL' || tag === 'OL' || tag === 'P';
+            });
+            let children: (CustomText | CustomElement)[];
+            if (hasBlock) {
+              // 直接递归所有子节点
+              children = el.childNodes
+                ? Array.from(el.childNodes).flatMap(child => processNode(child, {}))
+                : [];
+            } else {
+              // 包一层 paragraph
+              children = [
+                {
+                  type: 'paragraph',
+                  children: (el.childNodes
+                    ? Array.from(el.childNodes).flatMap(child => processNode(child, {}))
+                    : [{ text: '' }]) as (CustomText | CustomElement)[],
+                },
+              ];
+            }
+            result = {
+              type: 'list-item',
+              children: children as (CustomText | CustomElement)[],
+            };
+            break;
+          }
+          case 'pre': {
+            const codeEl = el.querySelector('code');
+            if (codeEl) {
+              result = {
+                type: 'code-block',
+                children: [{ text: codeEl.textContent || '' }],
+              } as any;
+            } else {
+              result = {
+                type: 'code-block',
+                children: [{ text: el.textContent || '' }],
+              } as any;
+            }
+            break;
+          }
+          case 'code': {
+            if (!el.closest('pre')) {
+              result = {
+                type: 'paragraph',
+                children: [{ text: el.textContent || '', code: true }],
+              } as ParagraphElement;
+            }
+            break;
+          }
+          case 'blockquote':
+            result = {
+              type: 'block-quote',
+              children: deserializeChildren(el),
+            } as BlockQuoteElement;
+            break;
+          case 'table':
+            result = deserializeTable(el);
+            break;
+          case 'think':
+            // 这里不再递归，直接跳过，由上层处理
+            return;
+          case 'retrive-tag': {
+            const id = el.getAttribute('id') || undefined;
+            const text = el.textContent || '';
+            result = [{ text, retrive: true, id }];
+            break;
+          }
+          case 'span':
+          case 'div': {
+            // flatten 所有子节点
+            let result: (CustomText | BaseElement)[] = [];
+            for (const child of Array.from(el.childNodes)) {
+              result = result.concat(processNode(child, {}));
+            }
+            return result;
+          }
+          default:
+            result = {
+              type: 'paragraph',
+              children: deserializeChildren(el),
+            } as ParagraphElement;
+            break;
+        }
+        if (Array.isArray(result)) {
+          result.forEach(item => {
+            if ('text' in item && !('type' in item)) {
+              if (elements.length === 0) {
+                elements.push({ type: 'paragraph', children: [item] } as ParagraphElement);
+              } else {
+                const last = elements[elements.length - 1];
+                if (Array.isArray(last.children)) {
+                  last.children.push(item);
+                }
+              }
+            } else {
+              elements.push(item);
+            }
+          });
+        } else if (result) {
+          elements.push(result);
+        }
+      } else if (child.nodeType === Node.TEXT_NODE && child.textContent?.trim()) {
+        elements.push({
+          type: 'paragraph',
+          children: [{ text: child.textContent }],
+        } as ParagraphElement);
+      }
+    });
+    return elements;
+  };
+  deNodes(elements, node.childNodes);
+  // console.log('elements:', elements)
+  return elements;
+}
+
+// 将 processNode 提升到 deserializeChildren 外部作用域
+function processNode(node: Node, styles: Partial<CustomText> = {}): (CustomText | CustomElement)[] {
+  if (node.nodeType === Node.TEXT_NODE) {
+    const text = node.textContent?.trim();
+    if (text) {
+      if (styles.code) {
+        // 如果是行内代码，解析其中的 Markdown 样式
+        return parseInlineCodeMarkdown(text);
+      } else {
+        return [{ text, ...styles }];
+      }
+    }
+    return [];
+  }
+
+  if (node.nodeType === Node.ELEMENT_NODE) {
+    const el = node as HTMLElement;
+    const currentStyles = { ...styles };
+
+    const tag = el.tagName?.toUpperCase?.() || '';
+
+    if (tag === 'UL' || tag === 'OL') {
+      return [
+        {
+          type: tag === 'UL' ? 'bulleted-list' : 'numbered-list',
+          children: (el.childNodes
+            ? Array.from(el.childNodes).flatMap(child => processNode(child, {}))
+            : []) as (CustomText | CustomElement)[],
+        },
+      ];
+    }
+    if (tag === 'LI') {
+      // 判断 li 里是否有 block 元素
+      const hasBlock = Array.from(el.childNodes).some(child => {
+        if (child.nodeType !== Node.ELEMENT_NODE) return false;
+        const tag = (child as HTMLElement).tagName?.toUpperCase?.();
+        return tag === 'UL' || tag === 'OL' || tag === 'P';
+      });
+      let children: (CustomText | CustomElement)[];
+      if (hasBlock) {
+        // 直接递归所有子节点
+        children = el.childNodes
+          ? Array.from(el.childNodes).flatMap(child => processNode(child, {}))
+          : [];
+      } else {
+        // 包一层 paragraph
+        children = [
+          {
+            type: 'paragraph',
+            children: (el.childNodes
+              ? Array.from(el.childNodes).flatMap(child => processNode(child, {}))
+              : [{ text: '' }]) as (CustomText | CustomElement)[],
+          },
+        ];
+      }
+      return [
+        {
+          type: 'list-item',
+          children: children as (CustomText | CustomElement)[],
+        },
+      ];
+    }
+    if (tag === 'TABLE') {
+      return [
+        {
+          type: 'table',
+          children: (el.childNodes
+            ? Array.from(el.childNodes).flatMap(child => processNode(child, {}))
+            : []) as (CustomText | CustomElement)[],
+        },
+      ];
+    }
+    if (tag === 'THEAD' || tag === 'TBODY') {
+      return (
+        el.childNodes ? Array.from(el.childNodes).flatMap(child => processNode(child, {})) : []
+      ) as (CustomText | CustomElement)[];
+    }
+    if (tag === 'TR') {
+      return [
+        {
+          type: 'table-row',
+          children: (el.childNodes
+            ? Array.from(el.childNodes).flatMap(child => processNode(child, {}))
+            : []) as (CustomText | CustomElement)[],
+        },
+      ];
+    }
+    if (tag === 'TD') {
+      return [
+        {
+          type: 'table-cell',
+          children: (el.childNodes
+            ? Array.from(el.childNodes).flatMap(child => processNode(child, {}))
+            : [{ text: '' }]) as (CustomText | CustomElement)[],
+        },
+      ];
+    }
+    if (tag === 'TH') {
+      return [
+        {
+          type: 'table-cell',
+          header: true,
+          children: (el.childNodes
+            ? Array.from(el.childNodes).flatMap(child => processNode(child, {}))
+            : [{ text: '' }]) as (CustomText | CustomElement)[],
+        },
+      ];
+    }
+    if (tag === 'THINK') {
+      return [
+        {
+          type: 'think',
+          children: (el.childNodes
+            ? Array.from(el.childNodes).flatMap(child => processNode(child, {}))
+            : []) as (CustomText | CustomElement)[],
+        } as any,
+      ];
+    }
+    if (tag === 'RETRIVE-TAG') {
+      // 收集所有 attribute
+      const attrs: Record<string, string> = {};
+      for (const attr of Array.from(el.attributes)) {
+        attrs[attr.name] = attr.value;
+      }
+      const children = el.childNodes
+        ? Array.from(el.childNodes).flatMap(child => {
+            const nodes = processNode(child, {});
+            return nodes.map(n =>
+              typeof n === 'object' && 'text' in n ? { ...n, retrive: true, ...attrs } : n
+            );
+          })
+        : [{ text: '', retrive: true, ...attrs }];
+      return children as (CustomText | CustomElement)[];
+    }
+    // 兜底：未知标签递归其所有子节点
+    if (el.childNodes && el.childNodes.length > 0) {
+      return Array.from(el.childNodes).flatMap(child => processNode(child, {})) as (
+        | CustomText
+        | CustomElement
+      )[];
+    }
+
+    switch (tag) {
+      case 'EM':
+      case 'I':
+        currentStyles.italic = true;
+        break;
+      case 'STRONG':
+      case 'B':
+        currentStyles.bold = true;
+        break;
+      case 'CODE':
+        if (!el.closest('pre')) {
+          currentStyles.code = true;
+        }
+        break;
+      case 'DEL':
+      case 'S':
+        currentStyles.strikethrough = true;
+        break;
+      case 'U':
+        currentStyles.underline = true;
+        break;
+      case 'A':
+        currentStyles.link = el.getAttribute('href') || undefined;
+        break;
+      case 'SPAN':
+      case 'DIV': {
+        // flatten 所有子节点
+        let result: (CustomText | CustomElement)[] = [];
+        for (const child of Array.from(el.childNodes)) {
+          result = result.concat(processNode(child, {}));
+        }
+        return result;
+      }
+      default:
+        break;
+    }
+  }
+  return [];
+}
+
+// 解析行内代码中的 Markdown 样式
+function parseInlineCodeMarkdown(text: string): CustomText[] {
+  const result: CustomText[] = [];
+  let currentText = '';
+  let isBold = false;
+  let isItalic = false;
+  let i = 0;
+
+  while (i < text.length) {
+    if (text.startsWith('**', i)) {
+      // 处理加粗
+      if (currentText) {
+        result.push({
+          text: currentText,
+          code: true,
+          bold: isBold,
+          italic: isItalic,
+        });
+        currentText = '';
+      }
+      isBold = !isBold;
+      i += 2;
+    } else if (text.startsWith('*', i)) {
+      // 处理斜体
+      if (currentText) {
+        result.push({
+          text: currentText,
+          code: true,
+          bold: isBold,
+          italic: isItalic,
+        });
+        currentText = '';
+      }
+      isItalic = !isItalic;
+      i += 1;
+    } else {
+      currentText += text[i];
+      i += 1;
+    }
+  }
+
+  if (currentText) {
+    result.push({
+      text: currentText,
+      code: true,
+      bold: isBold,
+      italic: isItalic,
+    });
+  }
+
+  return result;
+}
+
+// 保持 processNode 和 deserializeChildren 的实现
+function deserializeChildren(node: Node): (CustomText | BaseElement)[] {
+  const texts: (CustomText | BaseElement)[] = [];
+
+  for (const child of Array.from(node.childNodes)) {
+    texts.push(...processNode(child));
+  }
+
+  return texts;
+}
+
+function deserializeTable(tableEl: HTMLElement): TableElement {
+  const rows: TableRowElement[] = [];
+
+  // 处理表头
+  const thead = tableEl.querySelector('thead');
+  const tbody = tableEl.querySelector('tbody');
+
+  // 如果没有 thead 和 tbody，说明是简单表格，需要自动添加结构
+  if (!thead && !tbody) {
+    const allRows = Array.from(tableEl.querySelectorAll('tr'));
+    if (allRows.length > 0) {
+      // 第一行作为表头
+      rows.push({
+        type: 'table-row',
+        children: Array.from(allRows[0].children).map(
+          cell =>
+            ({
+              type: 'table-cell',
+              header: true,
+              children: deserializeChildren(cell),
+            }) as TableCellElement
+        ),
+      } as TableRowElement);
+
+      // 剩余行作为表格主体
+      allRows.slice(1).forEach(tr => {
+        rows.push({
+          type: 'table-row',
+          children: Array.from(tr.children).map(
+            cell =>
+              ({
+                type: 'table-cell',
+                header: false,
+                children: deserializeChildren(cell),
+              }) as TableCellElement
+          ),
+        } as TableRowElement);
+      });
+    }
+  } else {
+    // 处理表头
+    if (thead) {
+      const headerRow = thead.querySelector('tr');
+      if (headerRow) {
+        rows.push({
+          type: 'table-row',
+          children: Array.from(headerRow.querySelectorAll('th')).map(
+            cell =>
+              ({
+                type: 'table-cell',
+                header: true,
+                children: deserializeChildren(cell),
+              }) as TableCellElement
+          ),
+        } as TableRowElement);
+      }
+    }
+
+    // 处理表格主体
+    if (tbody) {
+      Array.from(tbody.querySelectorAll('tr')).forEach(tr => {
+        rows.push({
+          type: 'table-row',
+          children: Array.from(tr.querySelectorAll('td')).map(
+            cell =>
+              ({
+                type: 'table-cell',
+                header: false,
+                children: deserializeChildren(cell),
+              }) as TableCellElement
+          ),
+        } as TableRowElement);
+      });
+    }
+  }
+
+  return {
+    type: 'table',
+    children: rows,
+  } as TableElement;
+}
+
+function mergeHeadingAndList(html: string): string {
+  const div = document.createElement('div');
+  div.innerHTML = html;
+  let nodes = Array.from(div.childNodes);
+  let i = 0;
+  while (i < nodes.length - 1) {
+    const cur = nodes[i];
+    const next = nodes[i + 1];
+    // 支持 h2/h3/h4 + ul/ol/p/blockquote/pre
+    if (
+      cur.nodeType === 1 &&
+      ['H2', 'H3', 'H4'].includes((cur as HTMLElement).tagName) &&
+      next.nodeType === 1 &&
+      ['UL', 'OL', 'P', 'BLOCKQUOTE', 'PRE'].includes((next as HTMLElement).tagName)
+    ) {
+      // 创建 li
+      const li = document.createElement('li');
+      li.appendChild(cur.cloneNode(true));
+      li.appendChild(next.cloneNode(true));
+      // 检查后续是否还有连续的 ul/ol/p/blockquote/pre
+      let j = i + 2;
+      while (
+        j < nodes.length &&
+        nodes[j].nodeType === 1 &&
+        ['UL', 'OL', 'P', 'BLOCKQUOTE', 'PRE'].includes((nodes[j] as HTMLElement).tagName)
+      ) {
+        li.appendChild(nodes[j].cloneNode(true));
+        j++;
+      }
+      // 查找前面的 ol，没有就新建
+      let ol = null;
+      for (let k = i - 1; k >= 0; k--) {
+        if (nodes[k].nodeType === 1 && (nodes[k] as HTMLElement).tagName === 'OL') {
+          ol = nodes[k];
+          break;
+        }
+      }
+      if (!ol) {
+        ol = document.createElement('ol');
+        div.insertBefore(ol, cur);
+        nodes = Array.from(div.childNodes);
+        i = nodes.indexOf(ol);
+      }
+      ol.appendChild(li);
+      // 移除原 h2/h3/h4 和后续所有连续的 ul/ol/p/blockquote/pre
+      div.removeChild(cur);
+      div.removeChild(next);
+      for (let k = i + 1; k < j - 1; k++) {
+        div.removeChild(nodes[k + 1]);
+      }
+      // 重新获取 nodes
+      nodes = Array.from(div.childNodes);
+      i = -1; // 重新遍历
+    }
+    i++;
+  }
+  return div.innerHTML;
+}