@ant-design/agentic-ui 2.0.0

package/dist/MarkdownEditor/editor/parser/remarkParse.js

@@ -0,0 +1,118 @@
+// src/MarkdownEditor/editor/parser/remarkParse.ts
+import rehypeKatex from "rehype-katex";
+import rehypeRaw from "rehype-raw";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkHtml from "remark-html";
+import remarkMath from "remark-math";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { unified } from "unified";
+import { visit } from "unist-util-visit";
+function fixStrongWithSpecialChars() {
+  return (tree) => {
+    visit(tree, "paragraph", (paragraphNode) => {
+      if (Array.isArray(paragraphNode.children)) {
+        for (let i = 0; i < paragraphNode.children.length; i++) {
+          const child = paragraphNode.children[i];
+          if (child.type === "text" && child.value && typeof child.value === "string") {
+            const strongPattern = /\*\*([^*\n]*[$%#@&+\-=\w\d.，。、；：！？""''（）【】《》]+[^*\n]*?)\*\*/g;
+            if (strongPattern.test(child.value)) {
+              strongPattern.lastIndex = 0;
+              const newNodes = [];
+              let lastIndex = 0;
+              let match;
+              while ((match = strongPattern.exec(child.value)) !== null) {
+                if (match.index > lastIndex) {
+                  const beforeText = child.value.slice(lastIndex, match.index);
+                  if (beforeText) {
+                    newNodes.push({
+                      type: "text",
+                      value: beforeText
+                    });
+                  }
+                }
+                newNodes.push({
+                  type: "strong",
+                  children: [
+                    {
+                      type: "text",
+                      value: match[1]
+                    }
+                  ]
+                });
+                lastIndex = match.index + match[0].length;
+              }
+              if (lastIndex < child.value.length) {
+                const afterText = child.value.slice(lastIndex);
+                if (afterText) {
+                  newNodes.push({
+                    type: "text",
+                    value: afterText
+                  });
+                }
+              }
+              if (newNodes.length > 0) {
+                paragraphNode.children.splice(i, 1, ...newNodes);
+                i += newNodes.length - 1;
+              }
+            }
+          }
+        }
+      }
+    });
+    visit(tree, "text", (node, index, parent) => {
+      if (node.value && typeof node.value === "string") {
+        const strongPattern = /\*\*([^*\n]*[$%#@&+\-=\w\d.，。、；：！？""''（）【】《》]+[^*\n]*?)\*\*/g;
+        if (strongPattern.test(node.value)) {
+          strongPattern.lastIndex = 0;
+          const newNodes = [];
+          let lastIndex = 0;
+          let match;
+          while ((match = strongPattern.exec(node.value)) !== null) {
+            if (match.index > lastIndex) {
+              const beforeText = node.value.slice(lastIndex, match.index);
+              if (beforeText) {
+                newNodes.push({
+                  type: "text",
+                  value: beforeText
+                });
+              }
+            }
+            newNodes.push({
+              type: "strong",
+              children: [
+                {
+                  type: "text",
+                  value: match[1]
+                }
+              ]
+            });
+            lastIndex = match.index + match[0].length;
+          }
+          if (lastIndex < node.value.length) {
+            const afterText = node.value.slice(lastIndex);
+            if (afterText) {
+              newNodes.push({
+                type: "text",
+                value: afterText
+              });
+            }
+          }
+          if (parent && Array.isArray(parent.children) && typeof index === "number") {
+            parent.children.splice(index, 1, ...newNodes);
+          }
+        }
+      }
+    });
+  };
+}
+var markdownParser = unified().use(remarkParse).use(remarkHtml).use(remarkGfm).use(fixStrongWithSpecialChars).use(remarkMath, {
+  singleDollarTextMath: false
+  // 暂时禁用单美元符号，只使用双美元符号 $$...$$
+}).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeRaw).use(rehypeKatex).use(remarkFrontmatter, ["yaml"]);
+var remarkParse_default = markdownParser;
+export {
+  remarkParse_default as default,
+  fixStrongWithSpecialChars
+};

package/dist/MarkdownEditor/editor/plugins/catchError.d.ts

@@ -0,0 +1,2 @@
+import { Editor } from 'slate';
+export declare const withErrorReporting: (editor: any) => Editor;

package/dist/MarkdownEditor/editor/plugins/catchError.js

@@ -0,0 +1,20 @@
+// src/MarkdownEditor/editor/plugins/catchError.ts
+var tryCatchCallback = (editorFunc) => (...editorFuncArgs) => {
+  try {
+    return editorFunc(...editorFuncArgs);
+  } catch (error) {
+    console.error(error);
+    console.log(editorFuncArgs);
+  }
+};
+var withErrorReporting = (editor) => {
+  Object.entries(editor).forEach(([key, value]) => {
+    if (typeof value === "function") {
+      editor[key] = tryCatchCallback(value);
+    }
+  });
+  return editor;
+};
+export {
+  withErrorReporting
+};

package/dist/MarkdownEditor/editor/plugins/elements.d.ts

@@ -0,0 +1,29 @@
+import { Editor, Element, NodeEntry, Path, Range } from 'slate';
+import { Elements } from '../../el';
+export declare const insertAfter: (editor: Editor, path: Path, node?: Elements) => void;
+export type CheckMdParams = {
+    sel: Range;
+    editor: Editor;
+    path: Path;
+    match: RegExpMatchArray;
+    el: Element;
+    startText: string;
+};
+interface MdNode {
+    reg: RegExp;
+    matchKey?: string | RegExp;
+    checkAllow?: (ctx: {
+        editor: Editor;
+        node: NodeEntry<Element>;
+        sel: Range;
+    }) => boolean;
+    run: (ctx: CheckMdParams) => void | boolean;
+}
+export declare const MdElements: Record<string, MdNode>;
+export declare const BlockMathNodes: (MdNode & {
+    type: string;
+})[];
+export declare const TextMatchNodes: (MdNode & {
+    type: string;
+})[];
+export {};

package/dist/MarkdownEditor/editor/plugins/elements.js

@@ -0,0 +1,365 @@
+// src/MarkdownEditor/editor/plugins/elements.ts
+import {
+  Editor,
+  Node,
+  Path,
+  Point,
+  Range,
+  Transforms
+} from "slate";
+import { decodeURIComponentUrl } from "../parser/parserMarkdownToSlateNode";
+import { EditorUtils } from "../utils/editorUtils";
+var insertAfter = (editor, path, node = {
+  type: "paragraph",
+  children: [{ text: "" }]
+}) => {
+  const nextPath = Path.next(path);
+  Transforms.insertNodes(editor, node, { select: true, at: nextPath });
+};
+var matchText = (insert, matchString) => {
+  return (ctx) => {
+    const { sel, editor, match, startText } = ctx;
+    const leaf = Node.leaf(editor, sel.anchor.path);
+    if (EditorUtils.isDirtLeaf(leaf))
+      return false;
+    if (matchString) {
+      const preStr = Node.string(leaf) + matchString;
+      const prev = preStr[match.index - 1];
+      if (prev === matchString)
+        return false;
+    }
+    Transforms.select(editor, {
+      anchor: { path: sel.anchor.path, offset: match.index },
+      focus: {
+        path: sel.anchor.path,
+        offset: match.index + startText.length - 1
+      }
+    });
+    insert(ctx);
+    const addSel = editor.selection;
+    if (addSel)
+      EditorUtils.moveAfterSpace(editor, addSel.focus.path);
+    return true;
+  };
+};
+var MdElements = {
+  table: {
+    reg: /^\s*\|((?:[^|\n]+\|?)+)\|\s*$/,
+    run: ({ editor, path, match }) => {
+      const columns = match[1].split("|");
+      Transforms.delete(editor, { at: path });
+      Transforms.insertNodes(
+        editor,
+        EditorUtils.wrapperCardNode({
+          type: "table",
+          children: [
+            {
+              type: "table-row",
+              children: columns.map((c) => ({
+                type: "table-cell",
+                title: true,
+                children: [{ text: c }]
+              }))
+            },
+            {
+              type: "table-row",
+              children: columns.map(() => ({
+                type: "table-cell",
+                children: [{ text: "" }]
+              }))
+            }
+          ]
+        }),
+        { at: path }
+      );
+      Transforms.select(editor, [...path, 1, 0, 0]);
+    }
+  },
+  code: {
+    reg: /^\s*(```|···)([\w#\-+*]{1,30})?\s*$/,
+    run: ({ editor, path, match }) => {
+      const lang = match[2];
+      Transforms.delete(editor, { at: path });
+      Transforms.insertNodes(
+        editor,
+        {
+          type: "code",
+          language: lang,
+          value: ""
+        },
+        { at: path, select: true }
+      );
+      return true;
+    }
+  },
+  head: {
+    matchKey: " ",
+    checkAllow: (ctx) => {
+      var _a, _b;
+      return EditorUtils.isTop(ctx.editor, ctx.node[1]) && ["paragraph", "head"].includes((_b = (_a = ctx.node) == null ? void 0 : _a[0]) == null ? void 0 : _b.type) && !Path.hasPrevious(ctx.sel.anchor.path);
+    },
+    reg: /^\s*(#{1,5})(\s+)([^\n]*)$/,
+    run: ({ editor, path, match, sel }) => {
+      let text = [{ text: "" }];
+      if (!Point.equals(sel.anchor, Editor.end(editor, path))) {
+        text = EditorUtils.cutText(editor, sel.anchor);
+      }
+      Transforms.delete(editor, {
+        at: path
+      });
+      Transforms.insertNodes(
+        editor,
+        {
+          type: "head",
+          level: match[1].length,
+          children: text
+        },
+        {
+          at: path
+        }
+      );
+      Transforms.select(editor, Editor.start(editor, path));
+      return true;
+    }
+  },
+  link: {
+    reg: new RegExp("(?<!!)\\[([^]+)]\\(([^)]+)\\)\\s*"),
+    matchKey: ")",
+    run: ({ editor, match, sel, startText }) => {
+      Transforms.select(editor, {
+        anchor: { path: sel.anchor.path, offset: match.index },
+        focus: {
+          path: sel.anchor.path,
+          offset: match.index + startText.length
+        }
+      });
+      Transforms.insertNodes(editor, [
+        { text: match[1], url: match[2] },
+        { text: "" }
+      ]);
+      return true;
+    }
+  },
+  img: {
+    reg: /!\[([^]*)]\(([^)]+)\)\s*/,
+    matchKey: ")",
+    run: ({ editor, match, sel, startText }) => {
+      Transforms.select(editor, {
+        anchor: { path: sel.anchor.path, offset: match.index },
+        focus: {
+          path: sel.anchor.path,
+          offset: match.index + startText.length
+        }
+      });
+      Transforms.insertNodes(editor, [
+        EditorUtils.createMediaNode(
+          decodeURIComponentUrl(match[2] || ""),
+          "image",
+          {
+            alt: match[1]
+          }
+        )
+      ]);
+      return true;
+    }
+  },
+  task: {
+    reg: /^\s*\[(x|\s)]\s+/,
+    matchKey: " ",
+    checkAllow: (ctx) => {
+      var _a, _b;
+      if (((_b = (_a = ctx.node) == null ? void 0 : _a[0]) == null ? void 0 : _b.type) === "paragraph") {
+        const list = Editor.parent(ctx.editor, ctx.node[1])[0].type === "list-item";
+        return !(list && !Path.hasPrevious(ctx.node[1]));
+      }
+      return false;
+    },
+    run: (ctx) => {
+      Transforms.delete(ctx.editor, {
+        at: ctx.path
+      });
+      Transforms.insertNodes(
+        ctx.editor,
+        {
+          type: "list",
+          task: true,
+          children: [
+            {
+              type: "list-item",
+              checked: ctx.match[1] === "x",
+              children: [EditorUtils.p]
+            }
+          ]
+        },
+        { at: ctx.path }
+      );
+      Transforms.select(ctx.editor, Editor.start(ctx.editor, ctx.path).path);
+      return true;
+    }
+  },
+  list: {
+    matchKey: " ",
+    reg: /^\s*(\d+\.|-|\*|\+)\s+?/,
+    checkAllow: (ctx) => {
+      var _a, _b;
+      if (Editor.parent(ctx.editor, ctx.node[1])[0].type === "list-item") {
+        return Path.hasPrevious(ctx.node[1]);
+      }
+      return ["paragraph"].includes((_b = (_a = ctx.node) == null ? void 0 : _a[0]) == null ? void 0 : _b.type) && !Path.hasPrevious(ctx.sel.anchor.path);
+    },
+    run: ({ editor, match, sel, path }) => {
+      var _a;
+      const removeLength = ((_a = match[0].match(/\s*(\d+\.|-|\*|\+)\s+/)) == null ? void 0 : _a[0].length) || 0;
+      let texts = [{ text: "" }];
+      if (!Point.equals(sel.anchor, Editor.end(editor, path))) {
+        texts = EditorUtils.cutText(editor, sel.anchor);
+      }
+      Transforms.delete(editor, {
+        at: path
+      });
+      const start = match[1].match(/^\s*(\d+)\./);
+      Transforms.insertNodes(
+        editor,
+        {
+          type: "list",
+          order: !!start,
+          start: start ? +start[1] : void 0,
+          children: [
+            {
+              type: "list-item",
+              children: [{ type: "paragraph", children: texts }]
+            }
+          ]
+        },
+        { at: path }
+      );
+      Transforms.select(editor, {
+        path: Editor.start(editor, path).path,
+        offset: sel.anchor.offset - removeLength
+      });
+      return true;
+    }
+  },
+  hr: {
+    reg: /^\s*\*\*\*|___|---\s*/,
+    checkAllow: (ctx) => {
+      var _a, _b;
+      return ((_b = (_a = ctx.node) == null ? void 0 : _a[0]) == null ? void 0 : _b.type) === "paragraph" && ctx.node[1][0] !== 0;
+    },
+    run: ({ editor, path }) => {
+      Transforms.delete(editor, { at: path });
+      Transforms.insertNodes(
+        editor,
+        { type: "hr", children: [{ text: "" }] },
+        { at: path }
+      );
+      insertAfter(editor, path);
+    }
+  },
+  frontmatter: {
+    reg: /^\s*---\s*/,
+    checkAllow: (ctx) => {
+      var _a, _b;
+      return !Path.hasPrevious(ctx.node[1]) && ((_b = (_a = ctx.node) == null ? void 0 : _a[0]) == null ? void 0 : _b.type) === "paragraph" && EditorUtils.isTop(ctx.editor, ctx.node[1]);
+    },
+    run: ({ editor, path }) => {
+      Transforms.delete(editor, { at: path });
+      Transforms.insertNodes(
+        editor,
+        {
+          type: "code",
+          language: "yaml",
+          frontmatter: true,
+          children: [{ text: "" }]
+        },
+        { select: true, at: path }
+      );
+    }
+  },
+  blockquote: {
+    matchKey: " ",
+    reg: /^\s*>\s+([^\n]+)?/,
+    checkAllow: (ctx) => {
+      var _a, _b;
+      return ((_b = (_a = ctx.node) == null ? void 0 : _a[0]) == null ? void 0 : _b.type) === "paragraph";
+    },
+    run: ({ sel, editor, path }) => {
+      if (sel && Range.isCollapsed(sel)) {
+        const text = EditorUtils.cutText(editor, {
+          path: sel.anchor.path,
+          offset: 1
+        });
+        Transforms.delete(editor, {
+          at: path
+        });
+        Transforms.insertNodes(
+          editor,
+          {
+            type: "blockquote",
+            children: [{ type: "paragraph", children: text }]
+          },
+          { at: path }
+        );
+        Transforms.select(editor, Editor.start(editor, path));
+      }
+      return true;
+    }
+  },
+  bold: {
+    reg: /[*]{2}([^*][^\n]*)[*]{2}/,
+    matchKey: "*",
+    run: matchText(({ editor, match }) => {
+      Transforms.insertNodes(editor, [{ text: match[1], bold: true }], {
+        select: true
+      });
+    }, "*")
+  },
+  italic: {
+    reg: /[*]([^\n*]+)[*]/,
+    matchKey: "*",
+    run: matchText(({ editor, match }) => {
+      Transforms.insertNodes(editor, [{ text: match[1], italic: true }], {
+        select: true
+      });
+    }, "*")
+  },
+  inlineCode: {
+    reg: /`([^\n`]+)`/,
+    matchKey: "`",
+    run: matchText(({ editor, match }) => {
+      Transforms.insertNodes(editor, [{ text: match[1], code: true }]);
+    })
+  },
+  boldAndItalic: {
+    reg: /[*]{3}([^\n]+)[*]{3}/,
+    matchKey: "*",
+    run: matchText(({ editor, match }) => {
+      Transforms.insertNodes(
+        editor,
+        [{ text: match[1], italic: true, bold: true }],
+        {
+          select: true
+        }
+      );
+    })
+  },
+  strikethrough: {
+    reg: /~~([^\n]+)~~/,
+    matchKey: "~",
+    run: matchText(({ editor, match }) => {
+      Transforms.insertNodes(
+        editor,
+        [{ text: match[1], strikethrough: true }],
+        { select: true }
+      );
+    })
+  }
+};
+var BlockMathNodes = Object.entries(MdElements).filter((c) => !c[1].matchKey).map((c) => Object.assign(c[1], { type: c[0] }));
+var TextMatchNodes = Object.entries(MdElements).filter((c) => !!c[1].matchKey).map((c) => Object.assign(c[1], { type: c[0] }));
+export {
+  BlockMathNodes,
+  MdElements,
+  TextMatchNodes,
+  insertAfter
+};

package/dist/MarkdownEditor/editor/plugins/handlePaste.d.ts

@@ -0,0 +1,34 @@
+import { Editor } from 'slate';
+import { MarkdownEditorProps } from '../../BaseMarkdownEditor';
+/**
+ * 处理粘贴的 Slate Markdown 片段
+ */
+export declare const handleSlateMarkdownFragment: (editor: Editor, clipboardData: DataTransfer, currentTextSelection: any) => boolean;
+/**
+ * 处理粘贴的 HTML 内容
+ */
+export declare const handleHtmlPaste: (editor: Editor, clipboardData: DataTransfer, editorProps: MarkdownEditorProps) => Promise<boolean>;
+/**
+ * 处理粘贴的文件
+ */
+export declare const handleFilesPaste: (editor: Editor, clipboardData: DataTransfer, editorProps: MarkdownEditorProps) => Promise<boolean>;
+/**
+ * 处理特殊文本格式（media:// 和 attach:// 链接）
+ */
+export declare const handleSpecialTextPaste: (editor: Editor, text: string, selection: any) => boolean;
+/**
+ * 处理 HTTP 链接
+ */
+export declare const handleHttpLinkPaste: (editor: Editor, text: string, selection: any, store: any) => boolean;
+/**
+ * 处理普通文本粘贴
+ */
+export declare const handlePlainTextPaste: (editor: Editor, text: string, selection: any, plugins: any) => Promise<boolean>;
+/**
+ * 检查是否需要直接插入文本（在特定节点类型中）
+ */
+export declare const shouldInsertTextDirectly: (editor: Editor, selection: any) => boolean;
+/**
+ * 处理标签节点的粘贴
+ */
+export declare const handleTagNodePaste: (editor: Editor, currentTextSelection: any, clipboardData: DataTransfer, curNode: any) => boolean;