@ant-design/agentic-ui 2.29.10 → 2.29.12

package/dist/Bubble/MessagesContent/MarkdownPreview.js

@@ -93,21 +93,11 @@ import { MessagesContext } from "./BubbleContext";
  * ```
  */ export var MarkdownPreview = function(props) {
     var _props_originData;
-    var content = props.content, extra = props.extra, typing = props.typing, htmlRef = props.htmlRef, fncProps = props.fncProps, docListNode = props.docListNode, isFinished = props.isFinished, beforeContent = props.beforeContent, afterContent = props.afterContent;
+    var content = props.content, extra = props.extra, typing = props.typing, htmlRef = props.htmlRef, fncProps = props.fncProps, docListNode = props.docListNode, beforeContent = props.beforeContent, afterContent = props.afterContent;
     var MarkdownEditorRef = React.useRef(undefined);
     var hidePadding = (useContext(MessagesContext) || {}).hidePadding;
     var _ref = useContext(BubbleConfigContext) || {}, locale = _ref.locale, standalone = _ref.standalone;
     var token = theme.useToken().token;
-    useEffect(function() {
-        if (isFinished) {
-            var _MarkdownEditorRef_current;
-            console.log('content', content);
-            (_MarkdownEditorRef_current = MarkdownEditorRef.current) === null || _MarkdownEditorRef_current === void 0 ? void 0 : _MarkdownEditorRef_current.store.setContent(parserMdToSchema(content).schema);
-            return;
-        }
-    }, [
-        isFinished
-    ]);
     var isPaddingHidden = useMemo(function() {
         return !!extra;
     }, [
@@ -116,7 +106,6 @@ import { MessagesContext } from "./BubbleContext";
     ]);
     useEffect(function() {
         var _MarkdownEditorRef_current;
-        console.log("updatecontent", content);
         var schema = parserMdToSchema(content).schema;
         (_MarkdownEditorRef_current = MarkdownEditorRef.current) === null || _MarkdownEditorRef_current === void 0 ? void 0 : _MarkdownEditorRef_current.store.updateNodeList(schema);
     }, [

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

@@ -190,10 +190,10 @@ var parseCache = new Map();
     var configStr = config ? JSON.stringify(config) : '';
     var pluginsCount = (plugins === null || plugins === void 0 ? void 0 : plugins.length) || 0;
     var configHash = simpleHash("".concat(configStr, "_").concat(pluginsCount));
-    return mergedBlocks.map(function(content) {
+    return mergedBlocks.map(function(content, index) {
         return {
             content: content,
-            hash: "".concat(simpleHash(content), "_").concat(configHash)
+            hash: "".concat(simpleHash(content), "_").concat(configHash, "_").concat(index)
         };
     });
 };
@@ -593,9 +593,9 @@ var removeAnswerTags = function(text) {
         var blockHash = ((_blocks_ = blocks[0]) === null || _blocks_ === void 0 ? void 0 : _blocks_.hash) || simpleHash(md || '');
         // 为 schema 元素添加 hash
         return {
-            schema: result.schema.map(function(s) {
+            schema: result.schema.map(function(s, index) {
                 return _object_spread_props(_object_spread({}, s), {
-                    hash: blockHash
+                    hash: blockHash + '-' + index
                 });
             }),
             links: result.links

package/dist/MarkdownEditor/editor/store.js

@@ -1522,7 +1522,7 @@ export var EditorStoreContext = createContext(null);
    */ function executeOperations(operations) {
                 var editor = this._editor.current;
                 if (!editor) return;
-                // 使用批处理模式执行所有操作
+                // 使用批处理模式执行所有操作，避免中间状态导致路径变化
                 Editor.withoutNormalizing(editor, function() {
                     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     try {
@@ -1532,9 +1532,12 @@ export var EditorStoreContext = createContext(null);
                                 switch(op.type){
                                     case 'insert':
                                         if (op.node && editor.hasPath(Path.parent(op.path))) {
-                                            Transforms.insertNodes(editor, op.node, {
-                                                at: op.path
-                                            });
+                                            // 检查路径是否仍然有效，避免重复插入
+                                            if (!editor.hasPath(op.path)) {
+                                                Transforms.insertNodes(editor, op.node, {
+                                                    at: op.path
+                                                });
+                                            }
                                         }
                                         break;
                                     case 'remove':

package/dist/MarkdownEditor/editor/utils/editorCommands.d.ts

@@ -59,6 +59,7 @@ declare function convertToParagraph(editor: Editor): void;
  *
  * 将当前段落或标题节点转换为指定级别的标题。
  * 如果级别为4，则转换为普通段落。
+ * 如果存在选中文本，则只将选中的部分转换为标题，并拆分段落。
  *
  * @param editor Slate 编辑器实例
  * @param level 标题级别（1-3）或4（表示普通段落）

package/dist/MarkdownEditor/editor/utils/editorCommands.js

@@ -84,7 +84,7 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
-import { Editor, Element, Node, Path, Range, Transforms } from "slate";
+import { Editor, Element, Node, Path, Point, Range, Text, Transforms } from "slate";
 import { NativeTableEditor } from "../../utils/native-table";
 import { getListType, isListType } from "../plugins/withListsPlugin";
 import { EditorUtils } from "./editorUtils";
@@ -273,21 +273,249 @@ import { EditorUtils } from "./editorUtils";
         });
     }
 }
+/**
+ * 查找选区内的块级节点
+ *
+ * @param editor - 编辑器实例
+ * @param selection - 当前选区
+ * @returns 找到的块级节点数组，每个元素包含 [node, path]
+ */ function findBlockNodesInSelection(editor, selection) {
+    if (!selection) {
+        return [];
+    }
+    var blockNodes = Array.from(Editor.nodes(editor, {
+        at: selection,
+        match: function(n) {
+            return Element.isElement(n) && !Editor.isInline(editor, n) && [
+                'paragraph',
+                'head'
+            ].includes(n.type);
+        }
+    }));
+    return blockNodes;
+}
+/**
+ * 处理选区并设置标题格式
+ *
+ * @param editor - 编辑器实例
+ * @param selection - 选区范围
+ * @param level - 标题级别（1-3）
+ */ function processSelectionForHeading(editor, selection, level) {
+    var _Range_edges = _sliced_to_array(Range.edges(selection), 2), selStart = _Range_edges[0], selEnd = _Range_edges[1];
+    // 找到所有涉及选中文本的段落/标题节点
+    var blockNodes = findBlockNodesInSelection(editor, selection);
+    if (blockNodes.length === 0) {
+        return;
+    }
+    // 使用 withoutNormalizing 确保原子性操作
+    Editor.withoutNormalizing(editor, function() {
+        // 按路径倒序处理，从后往前，避免路径变化影响
+        var sortedNodes = _to_consumable_array(blockNodes).sort(function(a, b) {
+            return Path.compare(b[1], a[1]);
+        });
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = sortedNodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _step_value = _sliced_to_array(_step.value, 2), path = _step_value[1];
+                if (!Editor.hasPath(editor, path)) {
+                    continue;
+                }
+                var nodeStart = Editor.start(editor, path);
+                var nodeEnd = Editor.end(editor, path);
+                // 计算节点内的实际选区范围
+                var actualStart = Point.isBefore(selStart, nodeStart) ? nodeStart : Point.isAfter(selStart, nodeEnd) ? nodeEnd : selStart;
+                var actualEnd = Point.isAfter(selEnd, nodeEnd) ? nodeEnd : Point.isBefore(selEnd, nodeStart) ? nodeStart : selEnd;
+                // 检查是否选中了整个节点
+                var isWholeNodeSelected = (Point.isBefore(selStart, nodeStart) || Point.equals(selStart, nodeStart)) && (Point.isAfter(selEnd, nodeEnd) || Point.equals(selEnd, nodeEnd));
+                if (isWholeNodeSelected) {
+                    // 直接转换整个节点
+                    Transforms.setNodes(editor, {
+                        type: 'head',
+                        level: level
+                    }, {
+                        at: path
+                    });
+                    continue;
+                }
+                // 如果选区不在节点内，跳过
+                if (Point.isAfter(actualStart, actualEnd) || Point.equals(actualStart, actualEnd) || Point.isBefore(actualStart, nodeStart) || Point.isAfter(actualEnd, nodeEnd)) {
+                    continue;
+                }
+                // 情况1: 选中了整个节点（从开始到结束）
+                if (Point.equals(actualStart, nodeStart) && Point.equals(actualEnd, nodeEnd)) {
+                    Transforms.setNodes(editor, {
+                        type: 'head',
+                        level: level
+                    }, {
+                        at: path
+                    });
+                    continue;
+                }
+                // 情况2: 只选中了节点的一部分，需要拆分
+                var isAtStart = Point.equals(actualStart, nodeStart);
+                var isAtEnd = Point.equals(actualEnd, nodeEnd);
+                if (isAtStart && isAtEnd) {
+                    continue;
+                }
+                // 获取原节点的属性
+                var originalNode = Node.get(editor, path);
+                if (!Element.isElement(originalNode)) {
+                    continue;
+                }
+                if (isAtStart) {
+                    // 选中在开始位置：拆分成两个节点（选中部分 + 剩余部分）
+                    // 在 actualEnd 位置拆分节点
+                    Transforms.splitNodes(editor, {
+                        at: actualEnd
+                    });
+                    // 拆分后，原节点包含选中部分，新节点包含剩余部分
+                    // 将原节点（选中部分）转换为标题
+                    Transforms.setNodes(editor, {
+                        type: 'head',
+                        level: level
+                    }, {
+                        at: path
+                    });
+                } else if (isAtEnd) {
+                    // 选中在结束位置：拆分成两个节点（前面部分 + 选中部分）
+                    // 在 actualStart 位置拆分节点
+                    Transforms.splitNodes(editor, {
+                        at: actualStart
+                    });
+                    // 拆分后，原节点包含前面部分，新节点包含选中部分
+                    // 将新节点（选中部分）转换为标题
+                    var nextPath = Path.next(path);
+                    if (Editor.hasPath(editor, nextPath)) {
+                        Transforms.setNodes(editor, {
+                            type: 'head',
+                            level: level
+                        }, {
+                            at: nextPath
+                        });
+                    }
+                } else {
+                    // 选中在中间位置：拆分成三个节点（前面部分 + 选中部分 + 后面部分）
+                    // 计算选中部分的长度（字符偏移量）
+                    var selectionOffset = actualEnd.offset - actualStart.offset;
+                    // 第一步：在 actualStart 位置拆分节点
+                    Transforms.splitNodes(editor, {
+                        at: actualStart
+                    });
+                    // 拆分后，原节点包含前面部分，新节点包含选中部分和后面部分
+                    // 新节点的路径是 Path.next(path)
+                    var middlePath = Path.next(path);
+                    if (!Editor.hasPath(editor, middlePath)) {
+                        continue;
+                    }
+                    // 第二步：在新节点内计算拆分点
+                    // 使用偏移量来计算：在新节点开始位置 + 选中部分的长度
+                    // 需要找到对应的文本节点和偏移量
+                    var splitPoint = null;
+                    // 遍历新节点内的文本节点，计算正确的拆分点
+                    var textNodes = Array.from(Editor.nodes(editor, {
+                        at: middlePath,
+                        match: function(n) {
+                            return Text.isText(n);
+                        }
+                    }));
+                    var currentOffset = 0;
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        for(var _iterator1 = textNodes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var _step_value1 = _sliced_to_array(_step1.value, 2), textNode = _step_value1[0], textPath = _step_value1[1];
+                            if (!Text.isText(textNode)) {
+                                continue;
+                            }
+                            var text = textNode.text;
+                            if (typeof text !== 'string') {
+                                continue;
+                            }
+                            var textLength = text.length;
+                            var nextOffset = currentOffset + textLength;
+                            // 如果选中结束位置在这个文本节点内
+                            if (selectionOffset <= nextOffset) {
+                                var offsetInText = selectionOffset - currentOffset;
+                                splitPoint = {
+                                    path: textPath,
+                                    offset: offsetInText
+                                };
+                                break;
+                            }
+                            currentOffset = nextOffset;
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                    // 如果找不到拆分点，使用新节点的结束位置
+                    if (!splitPoint) {
+                        var middleNodeEnd = Editor.end(editor, middlePath);
+                        splitPoint = middleNodeEnd;
+                    }
+                    // 在新节点内的 splitPoint 位置拆分
+                    Transforms.splitNodes(editor, {
+                        at: splitPoint
+                    });
+                    // 拆分后，middlePath 包含选中部分，下一个节点包含后面部分
+                    // 将 middlePath（选中部分）转换为标题
+                    Transforms.setNodes(editor, {
+                        type: 'head',
+                        level: level
+                    }, {
+                        at: middlePath
+                    });
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    });
+}
 /**
  * 设置标题级别
  *
  * 将当前段落或标题节点转换为指定级别的标题。
  * 如果级别为4，则转换为普通段落。
+ * 如果存在选中文本，则只将选中的部分转换为标题，并拆分段落。
  *
  * @param editor Slate 编辑器实例
  * @param level 标题级别（1-3）或4（表示普通段落）
  */ export function setHeading(editor, level) {
     var _node_;
-    var _getCurrentNodes = _sliced_to_array(getCurrentNodes(editor), 1), node = _getCurrentNodes[0];
+    var selection = editor.selection;
+    // 如果级别为4，转换为段落
     if (level === 4) {
         convertToParagraph(editor);
         return;
     }
+    // 如果有非折叠的选区，处理选中文本
+    if (selection && !Range.isCollapsed(selection)) {
+        processSelectionForHeading(editor, selection, level);
+        return;
+    }
+    // 如果没有选区，保持原有行为：转换整个节点
+    var _getCurrentNodes = _sliced_to_array(getCurrentNodes(editor), 1), node = _getCurrentNodes[0];
     if (node && [
         'paragraph',
         'head'
@@ -301,27 +529,6 @@ import { EditorUtils } from "./editorUtils";
     }
 }
 export { convertToParagraph };
-/**
- * 查找选区内的块级节点
- *
- * @param editor - 编辑器实例
- * @param selection - 当前选区
- * @returns 找到的块级节点数组，每个元素包含 [node, path]
- */ function findBlockNodesInSelection(editor, selection) {
-    if (!selection) {
-        return [];
-    }
-    var blockNodes = Array.from(Editor.nodes(editor, {
-        at: selection,
-        match: function(n) {
-            return Element.isElement(n) && !Editor.isInline(editor, n) && [
-                'paragraph',
-                'head'
-            ].includes(n.type);
-        }
-    }));
-    return blockNodes;
-}
 /**
  * 将标题节点转换为段落节点
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ant-design/agentic-ui",
-  "version": "2.29.10",
+  "version": "2.29.12",
   "description": "面向智能体的 UI 组件库，提供多步推理可视化、工具调用展示、任务执行协同等 Agentic UI 能力",
   "repository": "git@github.com:ant-design/agentic-ui.git",
   "license": "MIT",
@@ -22,6 +22,7 @@
     "lint:css": "stylelint \"{src,test}/**/*.{css,less}\"",
     "lint:es": "eslint \"{src,test}/**/*.{js,jsx,ts,tsx}\"",
     "prepare": "husky install && dumi setup",
+    "prepublishOnly": "father doctor && pnpm run test && pnpm run build",
     "prettier": "prettier --write \"{src,docs,test}/**/*.{js,jsx,ts,tsx,css,less,json,md}\"",
     "preview": "pnpm dumi preview",
     "report:demo": "node scripts/generateDemoReport.js",