@ant-design/agentic-ui 2.0.0

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

@@ -0,0 +1,540 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/MarkdownEditor/editor/plugins/insertParsedHtmlNodes.ts
+import { message } from "antd";
+import { Editor, Element, Node, Path, Range, Transforms } from "slate";
+import { jsx } from "slate-hyperscript";
+import { debugLog, EditorUtils } from "../utils";
+import { docxDeserializer } from "../utils/docx/docxDeserializer";
+import { BackspaceKey } from "./hotKeyCommands/backspace";
+var BATCH_SIZE = 10;
+var BATCH_DELAY = 16;
+var MAX_SYNC_SIZE = 1e3;
+var findElementByNode = (node) => {
+  const index = Array.prototype.indexOf.call(node.parentNode.childNodes, node);
+  return node.parentElement.children[index];
+};
+var fragment = /* @__PURE__ */ new Set(["body", "figure", "div"]);
+var ELEMENT_TAGS = {
+  BLOCKQUOTE: () => ({ type: "blockquote" }),
+  H1: () => ({ type: "head", level: 1 }),
+  H2: () => ({ type: "head", level: 2 }),
+  H3: () => ({ type: "head", level: 3 }),
+  H4: () => ({ type: "head", level: 4 }),
+  H5: () => ({ type: "head", level: 5 }),
+  TABLE: () => ({ type: "table" }),
+  IMG: (el) => {
+    const src = el.src;
+    const alt = el.alt;
+    const isValidImageUrl = (url) => {
+      if (!url)
+        return false;
+      if (url.startsWith("blob:") || url.startsWith("data:")) {
+        return true;
+      }
+      if (!url.startsWith("http://") && !url.startsWith("https://")) {
+        return false;
+      }
+      const imageExtensions = [
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".gif",
+        ".svg",
+        ".webp",
+        ".bmp",
+        ".ico"
+      ];
+      const hasImageExtension = imageExtensions.some(
+        (ext) => url.toLowerCase().includes(ext)
+      );
+      const imagePaths = [
+        "/image",
+        "/img",
+        "/photo",
+        "/picture",
+        "/avatar",
+        "/icon"
+      ];
+      const hasImagePath = imagePaths.some(
+        (path) => url.toLowerCase().includes(path)
+      );
+      const hasImageContentType = url.includes("image/") || url.includes("img/");
+      return hasImageExtension || hasImagePath || hasImageContentType;
+    };
+    if (!isValidImageUrl(src)) {
+      return {
+        type: "paragraph",
+        children: [{ text: src || alt || "图片链接" }]
+      };
+    }
+    return EditorUtils.createMediaNode(src, "image", {
+      alt,
+      downloadUrl: src && /^https?:/.test(src) ? src : void 0
+    });
+  },
+  TR: () => ({ type: "table-row" }),
+  TH: () => ({ type: "table-cell", title: true }),
+  TD: () => ({ type: "table-cell" }),
+  LI: () => ({ type: "list-item" }),
+  OL: () => ({ type: "list", order: true }),
+  P: () => ({ type: "paragraph" }),
+  PRE: () => ({ type: "code" }),
+  UL: () => ({ type: "list" })
+};
+var TEXT_TAGS = {
+  A: (el) => ({ url: el.getAttribute("href") }),
+  CODE: () => ({ code: true }),
+  KBD: () => ({ code: true }),
+  SPAN: (el) => ({ text: el.textContent }),
+  DEL: () => ({ strikethrough: true }),
+  EM: () => ({ italic: true }),
+  I: () => ({ italic: true }),
+  S: () => ({ strikethrough: true }),
+  STRONG: () => ({ bold: true }),
+  B: () => ({ bold: true })
+};
+var deserialize = (el, parentTag = "") => {
+  if (el.nodeName.toLowerCase() === "script")
+    return [];
+  if (el.nodeName.toLowerCase() === "style")
+    return [];
+  if (el.nodeName.toLowerCase() === "meta")
+    return [];
+  if (el.nodeName.toLowerCase() === "link")
+    return [];
+  if (el.nodeName.toLowerCase() === "head")
+    return [];
+  if (el.nodeName.toLowerCase() === "colgroup")
+    return [];
+  if (el.nodeName.toLowerCase() === "noscript")
+    return [];
+  if (el.nodeType === 3) {
+    return el.textContent;
+  } else if (el.nodeType !== 1) {
+    return null;
+  } else if (el.nodeName === "BR") {
+    return "\n";
+  }
+  const { nodeName } = el;
+  let target = el;
+  if (nodeName === "PRE" && el.childNodes[0] && el.childNodes[0].nodeName === "CODE") {
+    target = el.childNodes[0];
+  }
+  let children = Array.from(target.childNodes).map((n) => {
+    return deserialize(n, target.nodeName.toLowerCase().toLowerCase());
+  }).flat();
+  if (children.length === 0) {
+    children = [{ text: el.textContent || "" }];
+  }
+  if (fragment.has(el.nodeName.toLowerCase())) {
+    return jsx("fragment", {}, children);
+  }
+  if (TEXT_TAGS[nodeName] && Array.from(el.childNodes).some(
+    (e) => e.nodeType !== 3 && !TEXT_TAGS[e.nodeName]
+  )) {
+    return jsx("fragment", {}, children);
+  }
+  if (ELEMENT_TAGS[nodeName]) {
+    if (!parentTag || !["h1", "h2", "code", "h3", "h4", "h5", "th", "td"].includes(parentTag)) {
+      if (nodeName === "PRE") {
+        const dom = findElementByNode(el);
+        const dataset = dom.dataset;
+        const inner = (dataset == null ? void 0 : dataset.blType) === "code";
+        if (inner) {
+          const value = Array.from(target.childNodes.values()).map((n) => {
+            var _a, _b;
+            return (_b = (_a = n.textContent) == null ? void 0 : _a.replace(/\n/g, "")) == null ? void 0 : _b.replace(/\t/g, "  ");
+          });
+          return {
+            type: "code",
+            language: dataset == null ? void 0 : dataset.blLang,
+            value,
+            children: [
+              {
+                text: value
+              }
+            ]
+          };
+        } else {
+          const text = parserCodeText(findElementByNode(target));
+          if (text) {
+            return {
+              type: "code",
+              value: text,
+              children: [
+                {
+                  text
+                }
+              ]
+            };
+          }
+        }
+        return null;
+      }
+      const attrs = ELEMENT_TAGS[nodeName](el);
+      return jsx("element", attrs, children);
+    }
+  }
+  if (TEXT_TAGS[nodeName]) {
+    const attrs = TEXT_TAGS[nodeName](el);
+    return children.map((child) => {
+      return jsx("text", attrs, child);
+    }).filter((c) => !!c.text);
+  }
+  return children;
+};
+var parserCodeText = (el) => {
+  el.innerHTML = el.innerHTML.replace(/<br\/?>|<\/div>(?=\S)/g, "\n");
+  return el.innerText;
+};
+var getTextsNode = (nodes) => {
+  let text = [];
+  for (let n of nodes) {
+    if (n.text) {
+      text.push(n);
+    }
+    if (n == null ? void 0 : n.children) {
+      text.push(...getTextsNode(n.children));
+    }
+  }
+  return text;
+};
+var blobToFile = (blobUrl, fileName) => __async(void 0, null, function* () {
+  const blob = yield fetch(blobUrl).then((r) => r.blob());
+  const file = new File([blob], fileName);
+  return file;
+});
+var upLoadFileBatch = (fragmentList, editorProps) => __async(void 0, null, function* () {
+  const mediaFragments = [];
+  const collectMediaFragments = (fragments) => {
+    for (const fragment2 of fragments) {
+      if (fragment2.type === "media") {
+        mediaFragments.push(fragment2);
+      }
+      if (fragment2 == null ? void 0 : fragment2.children) {
+        collectMediaFragments(fragment2.children);
+      }
+    }
+  };
+  collectMediaFragments(fragmentList);
+  if (mediaFragments.length === 0) {
+    return;
+  }
+  const hideLoading = message.loading(
+    `Uploading ${mediaFragments.length} files...`,
+    0
+  );
+  try {
+    for (let i = 0; i < mediaFragments.length; i += BATCH_SIZE) {
+      const batch = mediaFragments.slice(i, i + BATCH_SIZE);
+      yield Promise.all(
+        batch.map((fragment2) => __async(void 0, null, function* () {
+          var _a, _b;
+          const url = fragment2.url;
+          if (url == null ? void 0 : url.startsWith("blob:")) {
+            const file = yield blobToFile(fragment2 == null ? void 0 : fragment2.url, "image.png");
+            if ((_a = editorProps.image) == null ? void 0 : _a.upload) {
+              const serverUrl = [yield editorProps.image.upload([file])].flat(
+                1
+              );
+              fragment2.url = serverUrl == null ? void 0 : serverUrl[0];
+              fragment2.downloadUrl = serverUrl == null ? void 0 : serverUrl[0];
+            }
+          } else {
+            if ((_b = editorProps.image) == null ? void 0 : _b.upload) {
+              const serverUrl = [
+                yield editorProps.image.upload([fragment2 == null ? void 0 : fragment2.url])
+              ].flat(1);
+              fragment2.url = serverUrl == null ? void 0 : serverUrl[0];
+              fragment2.downloadUrl = serverUrl == null ? void 0 : serverUrl[0];
+            }
+          }
+        }))
+      );
+      const progress = Math.min(
+        (i + BATCH_SIZE) / mediaFragments.length * 100,
+        100
+      );
+      hideLoading();
+      message.loading(
+        `Uploading ${mediaFragments.length} files... ${Math.round(progress)}%`,
+        0
+      );
+      if (i + BATCH_SIZE < mediaFragments.length) {
+        yield new Promise((resolve) => setTimeout(resolve, BATCH_DELAY));
+      }
+    }
+    message.success("Upload completed");
+  } catch (error) {
+    console.error("文件上传失败:", error);
+    message.error("Some files failed to upload");
+  } finally {
+    hideLoading();
+  }
+});
+var insertNodesBatch = (editor, nodes, at, options) => __async(void 0, null, function* () {
+  if (nodes.length <= BATCH_SIZE) {
+    Transforms.insertNodes(editor, nodes, __spreadValues({ at }, options));
+    return;
+  }
+  for (let i = 0; i < nodes.length; i += BATCH_SIZE) {
+    const batch = nodes.slice(i, i + BATCH_SIZE);
+    const insertAt = at ? [...at.slice(0, -1), at[at.length - 1] + i] : void 0;
+    Transforms.insertNodes(editor, batch, {
+      at: insertAt,
+      select: (options == null ? void 0 : options.select) && i + BATCH_SIZE >= nodes.length
+    });
+    if (i + BATCH_SIZE < nodes.length) {
+      yield new Promise((resolve) => setTimeout(resolve, BATCH_DELAY));
+    }
+  }
+});
+var parseHtmlOptimized = (html, rtf) => __async(void 0, null, function* () {
+  if (html.length < MAX_SYNC_SIZE) {
+    return docxDeserializer(rtf, html.trim());
+  }
+  return new Promise((resolve) => {
+    const processInIdle = () => {
+      try {
+        const result = docxDeserializer(rtf, html.trim());
+        resolve(result);
+      } catch (error) {
+        console.error("HTML解析失败:", error);
+        resolve([]);
+      }
+    };
+    if ("requestIdleCallback" in window) {
+      requestIdleCallback(processInIdle, { timeout: 1e3 });
+    } else {
+      setTimeout(processInIdle, 0);
+    }
+  });
+});
+var htmlToFragmentList = (html, rtl) => {
+  let fragmentList = docxDeserializer(rtl, html.trim());
+  return fragmentList.map((fragment2) => {
+    if (fragment2.type === "table") {
+      return EditorUtils.wrapperCardNode(fragment2);
+    }
+    if (fragment2.type === '"paragraph"' && fragment2.children.length === 1) {
+      return {
+        type: "paragraph",
+        children: fragment2.children
+      };
+    }
+    return fragment2;
+  });
+};
+var insertParsedHtmlNodes = (editor, html, editorProps, rtl) => __async(void 0, null, function* () {
+  if (html.startsWith('<html>\r\n<body>\r\n<!--StartFragment--><img src="')) {
+    return false;
+  }
+  const hideLoading = message.loading("parsing...", 0);
+  try {
+    const fragmentList = yield parseHtmlOptimized(html, rtl);
+    if (!(fragmentList == null ? void 0 : fragmentList.length)) {
+      hideLoading();
+      return false;
+    }
+    yield upLoadFileBatch(fragmentList, editorProps);
+    debugLog("wordFragmentList", fragmentList);
+    hideLoading();
+    let [node] = Editor.nodes(editor, {
+      match: (n) => Element.isElement(n)
+    });
+    const selection = editor.selection;
+    if (!selection || !Editor.hasPath(editor, selection.anchor.path)) {
+      const processedNodes2 = fragmentList == null ? void 0 : fragmentList.map((item) => {
+        if (!item.type) {
+          return { type: "paragraph", children: [item] };
+        }
+        return item;
+      });
+      yield insertNodesBatch(editor, processedNodes2);
+      return true;
+    }
+    if (!Range.isCollapsed(selection)) {
+      const back = new BackspaceKey(editor);
+      back.range();
+      Transforms.select(editor, Range.start(selection));
+      setTimeout(() => {
+        var _a, _b;
+        const node2 = (_a = Editor) == null ? void 0 : _a.node(editor, [0]);
+        if (editor.children.length > 1 && ((_b = node2 == null ? void 0 : node2[0]) == null ? void 0 : _b.type) === "paragraph" && !Node.string(node2[0])) {
+          Transforms.delete(editor, { at: [0] });
+        }
+      });
+    }
+    const [specialNode] = Editor.nodes(editor, {
+      match: (n) => Element.isElement(n) && ["code", "table-cell", "head", "list-item"].includes(n.type),
+      at: Range.isCollapsed(selection) ? selection.anchor.path : Range.start(selection).path
+    });
+    if (specialNode) {
+      node = specialNode;
+    }
+    const parsed = new DOMParser().parseFromString(html, "text/html").body;
+    const inner = !!parsed.querySelector("[data-be]");
+    if ((node == null ? void 0 : node[0].type) === "code") {
+      const hasCodeTags = html.includes("<pre>") || html.includes("<code>") || inner;
+      if (hasCodeTags) {
+        const textContent = parsed.textContent || "";
+        if (textContent.trim()) {
+          Transforms.insertText(editor, textContent.trim(), { at: selection });
+          return true;
+        }
+      }
+    }
+    if (inner && (node == null ? void 0 : node[0].type) === "table-cell") {
+      return true;
+    }
+    if ((node == null ? void 0 : node[0].type) === "list-item" && fragmentList[0].type === "list") {
+      const children = fragmentList[0].children || [];
+      if (!children.length) {
+        return false;
+      }
+      const [p] = Editor.nodes(editor, {
+        match: (n) => Element.isElement(n) && n.type === "paragraph",
+        at: Range.isCollapsed(selection) ? selection.anchor.path : Range.start(selection).path
+      });
+      if (specialNode && !Path.hasPrevious(p[1])) {
+        if (!Node.string(p[0])) {
+          yield insertNodesBatch(editor, children, Path.next(specialNode[1]));
+          const parent = Node.parent(editor, p[1]);
+          const nextPath = [
+            ...specialNode[1].slice(0, -1),
+            specialNode[1][specialNode[1].length - 1] + children.length
+          ];
+          if (parent.children.length > 1) {
+            Transforms.moveNodes(editor, {
+              at: {
+                anchor: { path: Path.next(p[1]), offset: 0 },
+                focus: {
+                  path: [...p[1].slice(0, -1), parent.children.length - 1],
+                  offset: 0
+                }
+              },
+              to: [...nextPath, 1]
+            });
+          }
+          Transforms.delete(editor, { at: selection });
+        } else {
+          yield insertNodesBatch(editor, children, selection.anchor.path, {
+            select: true
+          });
+        }
+        if (fragmentList.length > 1) {
+          yield insertNodesBatch(
+            editor,
+            fragmentList.slice(1),
+            selection.anchor.path,
+            { select: true }
+          );
+        }
+        return true;
+      }
+    }
+    if ((node == null ? void 0 : node[0].type) === "table-cell") {
+      Transforms.insertFragment(editor, getTextsNode(fragmentList), {
+        at: selection
+      });
+      return true;
+    }
+    if ((node == null ? void 0 : node[0].type) === "head") {
+      if (fragmentList[0].type) {
+        if (fragmentList[0].type !== "paragraph") {
+          Transforms.insertNodes(
+            editor,
+            {
+              type: "paragraph",
+              children: [{ text: "" }]
+            },
+            { at: selection, select: true }
+          );
+          return true;
+        }
+        return false;
+      }
+      const texts = fragmentList.filter((c) => c.text);
+      if (texts.length) {
+        yield insertNodesBatch(editor, texts, selection.anchor.path);
+        return true;
+      }
+      return false;
+    }
+    if (fragmentList.length === 1 && (fragmentList[0].type === "paragraph" || !fragmentList[0].type) && node) {
+      const text = Node.string(fragmentList[0]);
+      if (text) {
+        Transforms.insertText(editor, text, {
+          at: selection
+        });
+        return true;
+      }
+    }
+    const processedNodes = fragmentList == null ? void 0 : fragmentList.map((item) => {
+      if (!item.type) {
+        return { type: "paragraph", children: [item] };
+      }
+      if (item.type === "code") {
+        return __spreadProps(__spreadValues({}, item), {
+          type: "code",
+          value: Node.string(item),
+          language: item.language || "txt"
+        });
+      }
+      return item;
+    });
+    yield insertNodesBatch(editor, processedNodes);
+    return true;
+  } catch (error) {
+    console.error("插入HTML节点失败:", error);
+    hideLoading();
+    message.error("Content parsing failed, please try again");
+    return false;
+  }
+});
+export {
+  ELEMENT_TAGS,
+  TEXT_TAGS,
+  deserialize,
+  htmlToFragmentList,
+  insertParsedHtmlNodes
+};

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

@@ -0,0 +1,11 @@
+import { Editor } from 'slate';
+import { MarkdownEditorPlugin } from '../../plugin';
+/**
+ * 解析Markdown并插入节点
+ *
+ * @param editor - 编辑器实例
+ * @param markdown - 要解析的Markdown字符串
+ * @param plugins - 可选的Markdown编辑器插件数组，用于扩展解析功能
+ * @returns 如果插入成功则返回true
+ */
+export declare const parseMarkdownToNodesAndInsert: (editor: Editor, markdown: string, plugins?: MarkdownEditorPlugin[]) => true | undefined;

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

@@ -0,0 +1,30 @@
+// src/MarkdownEditor/editor/plugins/parseMarkdownToNodesAndInsert.tsx
+import { Editor, Transforms } from "slate";
+import { parserMdToSchema } from "../parser/parserMdToSchema";
+var parseMarkdownToNodesAndInsert = (editor, markdown, plugins) => {
+  const nodes = JSON.parse(
+    JSON.stringify(parserMdToSchema(markdown, plugins).schema)
+  );
+  if (nodes.length === 0) {
+    nodes.push({ type: "paragraph", children: [{ text: "" }] });
+  }
+  const fragment = nodes;
+  const sel = editor.selection;
+  if (sel && Editor.hasPath(editor, sel.anchor.path)) {
+    if (editor.children.length < 1) {
+      Transforms.insertNodes(editor, fragment);
+      return;
+    }
+    const selectString = Editor.string(editor, sel);
+    if (selectString) {
+      Transforms.removeNodes(editor, { at: sel });
+    }
+    Transforms.insertNodes(editor, fragment, { at: sel });
+    return true;
+  }
+  Transforms.insertNodes(editor, fragment);
+  return true;
+};
+export {
+  parseMarkdownToNodesAndInsert
+};

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

@@ -0,0 +1,8 @@
+import { Editor, NodeEntry, Path, Range } from 'slate';
+import { EditorStore } from '../store';
+export declare const cacheTextNode: WeakMap<object, {
+    path: Path;
+    range: Range[];
+}>;
+export declare const clearInlineKatex: (editor: Editor) => void;
+export declare function useHighlight(store?: EditorStore): ([node, path]: NodeEntry) => Range[];