@ant-design/agentic-ui 2.0.0

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

@@ -0,0 +1,126 @@
+// src/MarkdownEditor/editor/plugins/useHighlight.ts
+import { Editor, Element, Node, Path } from "slate";
+import { EditorUtils } from "../utils/editorUtils";
+var htmlReg = /<[a-z]+[\s"'=:;()\w\-[\]/.]*\/?>(.*<\/[a-z]+>:?)?/g;
+var linkReg = /(https?|ftp):\/\/[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#/%=~_|]/gi;
+var cacheTextNode = /* @__PURE__ */ new WeakMap();
+var clearInlineKatex = (editor) => {
+  const inlineMath = Array.from(
+    Editor.nodes(editor, {
+      match: (n) => n.type === "inline-katex",
+      at: []
+    })
+  );
+  inlineMath.map((c) => cacheTextNode.delete(c[0]));
+};
+var highlightNodes = /* @__PURE__ */ new Set([
+  "paragraph",
+  "table-cell",
+  "table",
+  "code",
+  "head",
+  "inline-katex"
+]);
+function useHighlight(store) {
+  return ([node, path]) => {
+    if (Element.isElement(node) && highlightNodes.has(node.type)) {
+      const ranges = (store == null ? void 0 : store.highlightCache.get(node)) || [];
+      const cacheText = cacheTextNode.get(node);
+      if (["paragraph", "table-cell"].includes(node.type)) {
+        for (let i = 0; i < node.children.length; i++) {
+          const c = node.children[i];
+          if (c.text && !EditorUtils.isDirtLeaf(c)) {
+            if (cacheText && Path.equals(cacheText.path, path)) {
+              ranges.push(...cacheText.range);
+            } else {
+              let textRanges = [];
+              const matchHtml = c.text.matchAll(htmlReg);
+              for (let m of matchHtml) {
+                textRanges.push({
+                  anchor: { path: [...path, i], offset: m.index },
+                  focus: {
+                    path: [...path, i],
+                    offset: m.index + m[0].length
+                  },
+                  html: true
+                });
+              }
+              const match = c.text.matchAll(/\[\^.+?]:?/g);
+              for (let m of match) {
+                if (typeof m.index !== "number")
+                  continue;
+                textRanges.push({
+                  anchor: { path: [...path, i], offset: m.index },
+                  focus: {
+                    path: [...path, i],
+                    offset: m.index + m[0].length
+                  },
+                  fnc: !m[0].endsWith(":"),
+                  fnd: m[0].endsWith(":")
+                });
+              }
+              cacheTextNode.set(node, { path, range: textRanges });
+              ranges.push(...textRanges);
+            }
+          }
+          if (c.text && !c.url && !c.docId && !c.hash) {
+            let textRanges = [];
+            const links = c.text.matchAll(linkReg);
+            for (let m of links) {
+              textRanges.push({
+                anchor: { path: [...path, i], offset: m.index },
+                focus: {
+                  path: [...path, i],
+                  offset: m.index + m[0].length
+                },
+                link: m[0]
+              });
+            }
+            ranges.push(...textRanges);
+          }
+        }
+      }
+      if (node.type === "paragraph" && node.children.length === 1 && !EditorUtils.isDirtLeaf(node.children[0])) {
+        if (cacheText && Path.equals(cacheText.path, path)) {
+          ranges.push(...cacheText.range);
+        } else {
+          const str = Node.string(node);
+          if (str.startsWith("```")) {
+            ranges.push({
+              anchor: {
+                path: [...path, 0],
+                offset: 0
+              },
+              focus: {
+                path: [...path, 0],
+                offset: 3
+              },
+              color: "#a3a3a3"
+            });
+            cacheTextNode.set(node, { path, range: ranges });
+          } else if (/^\|([^|]+\|)+$/.test(str)) {
+            ranges.push({
+              anchor: {
+                path: [...path, 0],
+                offset: 0
+              },
+              focus: {
+                path: [...path, 0],
+                offset: str.length
+              },
+              color: "#a3a3a3"
+            });
+            cacheTextNode.set(node, { path, range: ranges });
+          }
+        }
+      }
+      return ranges;
+    }
+    return [];
+  };
+}
+export {
+  cacheTextNode,
+  clearInlineKatex,
+  useHighlight
+};

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

@@ -0,0 +1,47 @@
+import React from 'react';
+import { BaseEditor } from 'slate';
+import { HistoryEditor } from 'slate-history';
+import { ReactEditor } from 'slate-react';
+import { MarkdownEditorProps } from '../../BaseMarkdownEditor';
+import { EditorStore } from '../store';
+/**
+ * 键盘事件处理 Hook - 管理 Markdown 编辑器的所有键盘交互
+ *
+ * 该 Hook 负责拦截和处理各种键盘快捷键和特殊按键操作，提供丰富的编辑体验：
+ *
+ * 支持的快捷键操作：
+ * - Tab/Shift+Tab：代码块缩进控制、列表层级调整
+ * - Backspace：智能删除、格式清理、列表处理
+ * - Enter：段落分割、列表项创建、代码块换行
+ * - 方向键：光标移动、选择范围调整
+ * - Ctrl/Cmd 组合键：文本格式化（粗体、斜体等）
+ *
+ * 特殊功能：
+ * - 自动补全面板的键盘导航
+ * - 表格单元格间的 Tab 导航
+ * - 代码块的语法高亮触发
+ * - Markdown 语法的智能识别和转换
+ *
+ * @param store - 编辑器的全局状态管理对象
+ * @param markdownEditorRef - 指向 Slate.js 编辑器实例的引用
+ * @param props - 编辑器的属性配置对象
+ * @returns 返回键盘事件处理函数，用于绑定到 Slate.js 的 onKeyDown 属性
+ *
+ * @example
+ * ```typescript
+ * const onKeyDown = useKeyboard(store, editorRef, editorProps);
+ *
+ * return (
+ *   <Slate editor={editor} initialValue={value}>
+ *     <Editable onKeyDown={onKeyDown} />
+ *   </Slate>
+ * );
+ * ```
+ *
+ * @remarks
+ * - 所有按键处理都经过 isHotkey 库进行精确匹配
+ * - 支持跨平台快捷键（Windows/Mac）
+ * - 与编辑器状态深度集成，实现上下文相关的行为
+ * - 提供良好的用户体验和 Markdown 编辑效率
+ */
+export declare const useKeyboard: (store: EditorStore, markdownEditorRef: React.MutableRefObject<BaseEditor & ReactEditor & HistoryEditor>, props: MarkdownEditorProps) => (e: React.KeyboardEvent) => void;

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

@@ -0,0 +1,173 @@
+// src/MarkdownEditor/editor/plugins/useKeyboard.ts
+import isHotkey from "is-hotkey";
+import { useMemo } from "react";
+import {
+  Editor,
+  Element,
+  Node,
+  Path,
+  Range,
+  Transforms
+} from "slate";
+import { EditorUtils } from "../utils/editorUtils";
+import { BackspaceKey } from "./hotKeyCommands/backspace";
+import { EnterKey } from "./hotKeyCommands/enter";
+import { MatchKey } from "./hotKeyCommands/match";
+import { TabKey } from "./hotKeyCommands/tab";
+import { NativeTableKeyboard } from "../../utils/native-table";
+import { useEditorStore } from "../store";
+var useKeyboard = (store, markdownEditorRef, props) => {
+  const {
+    openInsertCompletion,
+    insertCompletionText$,
+    setOpenInsertCompletion
+  } = useEditorStore();
+  return useMemo(() => {
+    const tab = new TabKey(markdownEditorRef.current);
+    const backspace = new BackspaceKey(markdownEditorRef.current);
+    const enter = new EnterKey(store, backspace);
+    const match = new MatchKey(markdownEditorRef.current);
+    return (e) => {
+      var _a, _b, _c, _d, _e;
+      if (NativeTableKeyboard.shouldHandle(markdownEditorRef.current)) {
+        if (NativeTableKeyboard.handleKeyDown(
+          markdownEditorRef.current,
+          e.nativeEvent
+        )) {
+          return;
+        }
+      }
+      if (openInsertCompletion && (isHotkey("up", e) || isHotkey("down", e))) {
+        e.preventDefault();
+        return;
+      }
+      if (isHotkey("mod+ArrowDown", e)) {
+        e.preventDefault();
+        Transforms.select(
+          markdownEditorRef.current,
+          Editor.end(markdownEditorRef.current, [])
+        );
+      }
+      if (isHotkey("mod+ArrowUp", e)) {
+        e.preventDefault();
+        Transforms.select(
+          markdownEditorRef.current,
+          Editor.start(markdownEditorRef.current, [])
+        );
+      }
+      if (isHotkey("backspace", e) && markdownEditorRef.current.selection) {
+        if (Range.isCollapsed(markdownEditorRef.current.selection)) {
+          if (backspace.run()) {
+            e.stopPropagation();
+            e.preventDefault();
+            return;
+          }
+        }
+        if (backspace.range()) {
+          e.stopPropagation();
+          e.preventDefault();
+          return;
+        }
+      }
+      if (isHotkey("mod+shift+v", e)) {
+        e.preventDefault();
+      }
+      if (isHotkey("mod+alt+v", e) || isHotkey("mod+opt+v", e)) {
+        e.preventDefault();
+      }
+      if (isHotkey("mod+shift+s", e)) {
+        e.preventDefault();
+      }
+      if ((_a = props == null ? void 0 : props.markdown) == null ? void 0 : _a.matchInputToNode) {
+        match.run(e);
+        return;
+      }
+      if (e.key.toLowerCase().startsWith("arrow")) {
+        if (["ArrowUp", "ArrowDown"].includes(e.key))
+          return;
+        if (e.key === "ArrowLeft") {
+          const selection = markdownEditorRef.current.selection;
+          if (selection && Range.isCollapsed(selection)) {
+            const [node2] = Editor.nodes(markdownEditorRef.current, {
+              at: selection.focus.path,
+              match: (n) => n.tag === true
+            });
+            if (node2) {
+              const [, tagPath] = node2;
+              const offset = selection.focus.offset;
+              if (offset === 0) {
+                const [prevNode] = Editor.previous(markdownEditorRef.current, { at: tagPath }) || [];
+                if (!prevNode || !((_b = prevNode.text) == null ? void 0 : _b.endsWith("\uFEFF"))) {
+                  e.preventDefault();
+                  Transforms.insertNodes(
+                    markdownEditorRef.current,
+                    [{ text: "\uFEFF" }],
+                    {
+                      at: tagPath,
+                      select: true
+                    }
+                  );
+                  return;
+                }
+              }
+            }
+          }
+        }
+        return;
+      }
+      if (e.key === "Tab")
+        tab.run(e);
+      if (((_c = props.textAreaProps) == null ? void 0 : _c.triggerSendKey) === "Enter") {
+        if (e.key === "Enter" && (e.ctrlKey || e.metaKey)) {
+          e.stopPropagation();
+          e.preventDefault();
+          enter.run(e);
+          return;
+        }
+        return;
+      }
+      if (((_d = props.textAreaProps) == null ? void 0 : _d.triggerSendKey) === "Mod+Enter") {
+        if (e.key === "Enter" && !(e.ctrlKey || e.metaKey)) {
+          e.stopPropagation();
+          e.preventDefault();
+          enter.run(e);
+        }
+        return;
+      }
+      if (e.key === "Enter" && !(e.ctrlKey || e.metaKey)) {
+        e.stopPropagation();
+        e.preventDefault();
+        enter.run(e);
+      }
+      const [node] = Editor.nodes(markdownEditorRef.current, {
+        match: (n) => Element.isElement(n),
+        mode: "lowest"
+      });
+      if (!node)
+        return;
+      if (((_e = node == null ? void 0 : node[0]) == null ? void 0 : _e.type) === "paragraph") {
+        const [node2] = Editor.nodes(markdownEditorRef.current, {
+          match: (n) => Element.isElement(n) && n.type === "paragraph",
+          mode: "lowest"
+        });
+        if (node2 && node2[0].children.length === 1 && !EditorUtils.isDirtLeaf(node2[0].children[0]) && (e.key === "Backspace" || /^[^\n]$/.test(e.key))) {
+          let str = Node.string(node2[0]) || "";
+          const codeMatch = str.match(/^```([\w+\-#]+)$/i);
+          if (codeMatch) {
+          } else {
+            const insertMatch = str.match(/^\/([^\n]+)?$/i);
+            if (insertMatch && !(!Path.hasPrevious(node2[1]) && Node.parent(markdownEditorRef.current, node2[1]).type === "list-item")) {
+              setOpenInsertCompletion == null ? void 0 : setOpenInsertCompletion(true);
+              setTimeout(() => {
+                insertCompletionText$.next(insertMatch[1]);
+              });
+            }
+          }
+        }
+      }
+    };
+  }, [markdownEditorRef.current]);
+};
+export {
+  useKeyboard
+};

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

@@ -0,0 +1,17 @@
+import { Subject } from 'rxjs';
+import { BaseOperation, BaseSelection, Editor, NodeEntry } from 'slate';
+import { Elements } from '../../el';
+export declare const selChange$: Subject<{
+    sel: BaseSelection;
+    node: NodeEntry<any>;
+} | null>;
+/**
+ * 用于处理编辑器内容变化的自定义钩子函数。
+ *
+ * @param editor - Slate 编辑器实例。
+ * @param store - 编辑器状态存储实例。
+ * @param onChange - 可选的回调函数，当编辑器内容变化时调用，传递 Markdown 格式的内容和元素数组。
+ *
+ * @returns 一个函数，用于处理编辑器内容变化。
+ */
+export declare function useOnchange(editor: Editor, onChange?: (value: string, schema: Elements[]) => void): (_value: any, _operations: BaseOperation[]) => void;

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

@@ -0,0 +1,101 @@
+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/useOnchange.ts
+import { useDebounceFn } from "@ant-design/pro-components";
+import React, { useRef } from "react";
+import { Subject } from "rxjs";
+import {
+  Editor,
+  Element,
+  Path,
+  Range
+} from "slate";
+import { useEditorStore } from "../store";
+import { parserSlateNodeToMarkdown } from "../utils";
+var selChange$ = new Subject();
+var floatBarIgnoreNode = /* @__PURE__ */ new Set(["code"]);
+function useOnchange(editor, onChange) {
+  const rangeContent = useRef("");
+  const onChangeDebounce = useDebounceFn(() => __async(this, null, function* () {
+    if (!onChange)
+      return;
+    onChange == null ? void 0 : onChange(parserSlateNodeToMarkdown(editor.children), editor.children);
+  }), 16);
+  const { setRefreshFloatBar, setDomRect, refreshFloatBar } = useEditorStore();
+  return React.useMemo(() => {
+    return (_value, _operations) => {
+      var _a, _b;
+      if (onChangeDebounce && _operations.some((o) => o.type !== "set_selection")) {
+        onChangeDebounce.cancel();
+        onChangeDebounce == null ? void 0 : onChangeDebounce.run(parserSlateNodeToMarkdown(_value), _value);
+      }
+      const sel = editor.selection;
+      try {
+        const [node] = Editor.nodes(editor, {
+          match: (n) => Element.isElement(n),
+          mode: "lowest"
+        });
+        setTimeout(() => {
+          selChange$.next({
+            sel,
+            node
+          });
+        });
+        if (!node)
+          return;
+        setTimeout(() => {
+          selChange$.next({
+            sel,
+            node
+          });
+        });
+        if (_operations.some((o) => o.type === "set_selection") && sel && !floatBarIgnoreNode.has((_a = node == null ? void 0 : node[0]) == null ? void 0 : _a.type) && !Range.isCollapsed(sel) && Path.equals(Path.parent(sel.focus.path), Path.parent(sel.anchor.path))) {
+          if (typeof window === "undefined")
+            return;
+          const domSelection = window.getSelection();
+          const domRange = domSelection == null ? void 0 : domSelection.getRangeAt(0);
+          if (!((_b = domRange == null ? void 0 : domRange.toString()) == null ? void 0 : _b.trim()))
+            return;
+          if (rangeContent.current === (domRange == null ? void 0 : domRange.toString())) {
+            setRefreshFloatBar == null ? void 0 : setRefreshFloatBar(!refreshFloatBar);
+            return;
+          }
+          rangeContent.current = (domRange == null ? void 0 : domRange.toString()) || "";
+          const rect = domRange == null ? void 0 : domRange.getBoundingClientRect();
+          if (rect) {
+            setDomRect == null ? void 0 : setDomRect(rect);
+          } else {
+            setDomRect == null ? void 0 : setDomRect(null);
+          }
+        } else {
+          rangeContent.current = "";
+          setDomRect == null ? void 0 : setDomRect(null);
+        }
+      } catch (error) {
+      }
+    };
+  }, [editor]);
+}
+export {
+  selChange$,
+  useOnchange
+};

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

@@ -0,0 +1,22 @@
+import { Editor } from 'slate';
+import { ReactEditor } from 'slate-react';
+export declare const inlineNode: Set<string>;
+/**
+ * 为Slate编辑器添加Markdown支持的插件函数
+ *
+ * @param editor - 要扩展的Slate编辑器实例
+ * @returns 增强后的编辑器实例，具有Markdown处理能力
+ *
+ * @description
+ * 该插件通过扩展编辑器的基本功能，使其能够处理和渲染Markdown内容：
+ * - 扩展`isInline`方法，识别特定的行内元素
+ * - 扩展`isVoid`方法，识别特定的空元素
+ * - 重写`apply`方法，添加自定义操作处理逻辑
+ * - 重写`deleteBackward`方法，处理特殊节点的删除行为
+ *
+ * 自定义操作处理流程：
+ * 1. 按顺序尝试所有专用处理函数（表格、卡片、链接、Schema等）
+ * 2. 如果任一处理函数返回true，则操作被消费
+ * 3. 否则，调用原始的apply方法处理操作
+ */
+export declare const withMarkdown: (editor: Editor) => import("slate").BaseEditor & ReactEditor & import("slate-history").HistoryEditor;