@ant-design/agentic-ui 2.29.8 → 2.29.10

package/dist/Bubble/MessagesContent/MarkdownPreview.js

@@ -101,7 +101,8 @@ import { MessagesContext } from "./BubbleContext";
     useEffect(function() {
         if (isFinished) {
             var _MarkdownEditorRef_current;
-            (_MarkdownEditorRef_current = MarkdownEditorRef.current) === null || _MarkdownEditorRef_current === void 0 ? void 0 : _MarkdownEditorRef_current.store.setMDContent(content);
+            console.log('content', content);
+            (_MarkdownEditorRef_current = MarkdownEditorRef.current) === null || _MarkdownEditorRef_current === void 0 ? void 0 : _MarkdownEditorRef_current.store.setContent(parserMdToSchema(content).schema);
             return;
         }
     }, [
@@ -115,6 +116,7 @@ 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/plugins/hotKeyCommands/backspace.js

@@ -167,37 +167,16 @@ export var BackspaceKey = /*#__PURE__*/ function() {
                     var _parent_1;
                     var parent1 = Editor.parent(this.editor, path);
                     if ((parent1 === null || parent1 === void 0 ? void 0 : (_parent_1 = parent1[0]) === null || _parent_1 === void 0 ? void 0 : _parent_1.type) === 'list-item') {
-                        // 处理行首 Backspace 减少缩进
-                        if (Range.isCollapsed(sel) && sel.anchor.offset === 0) {
-                            var listItemPath = parent1[1];
-                            var listPath = Path.parent(listItemPath);
-                            var list = Node.get(this.editor, listPath);
-                            if (isListType(list)) {
-                                var listParent = Editor.parent(this.editor, listPath);
-                                // 如果父节点是 list-item，说明在嵌套列表中，可以提升
-                                if (Element.isElement(listParent[0]) && listParent[0].type === 'list-item') {
-                                    // 使用 liftNodes 提升当前 list-item
-                                    Transforms.liftNodes(this.editor, {
-                                        at: listItemPath
-                                    });
-                                    // 如果提升后，原列表为空，需要删除空列表
-                                    var updatedList = Node.get(this.editor, listPath);
-                                    if (isListType(updatedList) && updatedList.children.length === 0) {
-                                        Transforms.removeNodes(this.editor, {
-                                            at: listPath
-                                        });
-                                    }
-                                    return true;
-                                }
-                            }
-                        }
-                        if (Node.string(parent1[0]) !== '') {
-                            return false;
-                        }
-                        if (Node.string(parent1[0]) === '') {
+                        // 先检查 list-item 是否为空：检查第一个段落（子节点）是否为空
+                        var listItem = parent1[0];
+                        var firstChild = Element.isElement(listItem) && listItem.children.length > 0 ? listItem.children[0] : null;
+                        var isEmptyListItem = firstChild && Element.isElement(firstChild) && firstChild.type === 'paragraph' && Node.string(firstChild).trim() === '' && listItem.children.length === 1; // 只有第一个段落，没有嵌套列表
+                        console.log('isEmptyListItem', isEmptyListItem);
+                        // 如果 list-item 为空，优先执行删除逻辑
+                        if (isEmptyListItem) {
                             // 使用新的拆分逻辑处理空的list-item
-                            var listPath1 = Path.parent(parent1[1]);
-                            var listNode = Editor.node(this.editor, listPath1);
+                            var listPath = Path.parent(parent1[1]);
+                            var listNode = Editor.node(this.editor, listPath);
                             var currentItemIndex = parent1[1][parent1[1].length - 1];
                             var isLastItem = currentItemIndex === listNode[0].children.length - 1;
                             if (isLastItem) {
@@ -207,10 +186,10 @@ export var BackspaceKey = /*#__PURE__*/ function() {
                                     at: parent1[1]
                                 });
                                 // 如果列表为空，删除列表容器
-                                var updatedList1 = Node.get(this.editor, listPath1);
-                                if (isListType(updatedList1) && updatedList1.children.length === 0) {
+                                var updatedList = Node.get(this.editor, listPath);
+                                if (isListType(updatedList) && Node.string(updatedList).trim() === '') {
                                     Transforms.removeNodes(this.editor, {
-                                        at: listPath1
+                                        at: listPath
                                     });
                                     // 在列表位置插入 paragraph
                                     Transforms.insertNodes(this.editor, {
@@ -221,7 +200,7 @@ export var BackspaceKey = /*#__PURE__*/ function() {
                                             }
                                         ]
                                     }, {
-                                        at: listPath1,
+                                        at: listPath,
                                         select: true
                                     });
                                 } else {
@@ -243,7 +222,7 @@ export var BackspaceKey = /*#__PURE__*/ function() {
                                 // 先删除后面的 items（从后往前删除，避免索引变化）
                                 for(var i = listNode[0].children.length - 1; i > currentItemIndex; i--){
                                     Transforms.removeNodes(this.editor, {
-                                        at: _to_consumable_array(listPath1).concat([
+                                        at: _to_consumable_array(listPath).concat([
                                             i
                                         ])
                                     });
@@ -253,11 +232,11 @@ export var BackspaceKey = /*#__PURE__*/ function() {
                                     at: parent1[1]
                                 });
                                 // 检查列表是否为空，如果为空则删除列表容器
-                                var updatedList2 = Node.get(this.editor, listPath1);
-                                if (isListType(updatedList2) && updatedList2.children.length === 0) {
+                                var updatedList1 = Node.get(this.editor, listPath);
+                                if (isListType(updatedList1) && Node.string(updatedList1).trim() === '') {
                                     // 列表为空，删除列表容器
                                     Transforms.removeNodes(this.editor, {
-                                        at: listPath1
+                                        at: listPath
                                     });
                                     // 在列表位置插入 paragraph
                                     Transforms.insertNodes(this.editor, {
@@ -268,13 +247,13 @@ export var BackspaceKey = /*#__PURE__*/ function() {
                                             }
                                         ]
                                     }, {
-                                        at: listPath1,
+                                        at: listPath,
                                         select: true
                                     });
                                 } else {
                                     // 列表还有前面的 items，保持列表
                                     // 在列表后插入 paragraph
-                                    var insertPath = Path.next(listPath1);
+                                    var insertPath = Path.next(listPath);
                                     Transforms.insertNodes(this.editor, {
                                         type: 'paragraph',
                                         children: [
@@ -290,6 +269,31 @@ export var BackspaceKey = /*#__PURE__*/ function() {
                             }
                             return true;
                         }
+                        // 如果 list-item 不为空，处理行首 Backspace 减少缩进
+                        if (Range.isCollapsed(sel) && sel.anchor.offset === 0) {
+                            var listItemPath = parent1[1];
+                            var listPath1 = Path.parent(listItemPath);
+                            var list = Node.get(this.editor, listPath1);
+                            if (isListType(list)) {
+                                var listParent = Editor.parent(this.editor, listPath1);
+                                // 如果父节点是 list-item，说明在嵌套列表中，可以提升
+                                if (listParent && listParent[0] && Element.isElement(listParent[0]) && listParent[0].type === 'list-item') {
+                                    // 使用 liftNodes 提升当前 list-item
+                                    Transforms.liftNodes(this.editor, {
+                                        at: listItemPath
+                                    });
+                                    // 如果提升后，原列表为空，需要删除空列表
+                                    var updatedList2 = Node.get(this.editor, listPath1);
+                                    if (isListType(updatedList2) && Node.string(updatedList2).trim() === '') {
+                                        Transforms.removeNodes(this.editor, {
+                                            at: listPath1
+                                        });
+                                    }
+                                    return true;
+                                }
+                            }
+                        }
+                        return false;
                     }
                 }
                 /**

package/dist/MarkdownEditor/editor/plugins/hotKeyCommands/enter.js

@@ -299,6 +299,8 @@ export var EnterKey = /*#__PURE__*/ function() {
                             });
                         } else if (!Path.hasPrevious(path)) {
                             e.preventDefault();
+                            // 在列表项开头按回车时，只创建新的空列表项，不移动任何节点
+                            // 这样可以避免将嵌套列表或其他节点移动到新列表项内部，导致缩进
                             Transforms.insertNodes(this.editor, {
                                 type: 'list-item',
                                 checked: typeof parent.checked === 'boolean' ? false : undefined,
@@ -309,9 +311,6 @@ export var EnterKey = /*#__PURE__*/ function() {
                                 at: Path.next(parentPath),
                                 select: true
                             });
-                            var cur = Path.next(path);
-                            var index = 1;
-                            EditorUtils.moveNodes(this.editor, cur, Path.next(parentPath), index);
                         }
                     }
                 }
@@ -575,9 +574,8 @@ export var EnterKey = /*#__PURE__*/ function() {
                         if (Editor.start(this.editor, Path.next(parent[1]))) {
                             Transforms.select(this.editor, Editor.start(this.editor, Path.next(parent[1])));
                         }
-                        if (Editor.hasPath(this.editor, Path.next(node[1]))) {
-                            EditorUtils.moveNodes(this.editor, Path.next(node[1]), Path.next(parent[1]), 1);
-                        }
+                        // 不再移动任何节点到新列表项内部，避免导致新列表项被缩进
+                        // 嵌套列表应该保留在原列表项中
                         return true;
                     }
                 }

package/dist/MarkdownEditor/editor/plugins/hotKeyCommands/tab.js

@@ -89,7 +89,7 @@ function _unsupported_iterable_to_array(o, minLen) {
     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, Point, Range, Text, Transforms } from "slate";
-import { isListType, getListType } from "../withListsPlugin";
+import { getListType, isListType } from "../withListsPlugin";
 /**
  * TabKey 类用于处理编辑器中的 Tab 键事件。
  */ export var TabKey = /*#__PURE__*/ function() {
@@ -235,7 +235,7 @@ import { isListType, getListType } from "../withListsPlugin";
             key: "listItem",
             value: /**
    * 处理列表项的 Tab/Shift+Tab 键
-   * 
+   *
    * Tab: 增加缩进（将当前 list-item 移动到前一个 list-item 的子列表中）
    * Shift+Tab: 减少缩进（将当前 list-item 提升一级）
    */ function listItem(node, e) {
@@ -347,7 +347,7 @@ import { isListType, getListType } from "../withListsPlugin";
                     });
                     // 如果提升后，原列表为空，需要删除空列表
                     var updatedList = Node.get(this.editor, listPath);
-                    if (isListType(updatedList) && updatedList.children.length === 0) {
+                    if (isListType(updatedList) && Node.string(updatedList).trim() === '') {
                         Transforms.removeNodes(this.editor, {
                             at: listPath
                         });

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

@@ -1,9 +1,9 @@
-export * from './withMarkdown';
-export * from './withInlineNodes';
-export * from './withVoidNodes';
+export * from './utils';
 export * from './withCardPlugin';
+export * from './withCodeTagPlugin';
+export * from './withInlineNodes';
 export * from './withLinkAndMediaPlugin';
 export * from './withListsPlugin';
+export * from './withMarkdown';
 export * from './withSchemaPlugin';
-export * from './withCodeTagPlugin';
-export * from './utils';
+export * from './withVoidNodes';

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

@@ -1,9 +1,9 @@
-export * from "./withMarkdown";
-export * from "./withInlineNodes";
-export * from "./withVoidNodes";
+export * from "./utils";
 export * from "./withCardPlugin";
+export * from "./withCodeTagPlugin";
+export * from "./withInlineNodes";
 export * from "./withLinkAndMediaPlugin";
 export * from "./withListsPlugin";
+export * from "./withMarkdown";
 export * from "./withSchemaPlugin";
-export * from "./withCodeTagPlugin";
-export * from "./utils";
+export * from "./withVoidNodes";

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

@@ -197,30 +197,49 @@ import { useEditorStore } from "../store";
                 enter.run(e);
                 return;
             }
-            // Enter 键（无 Shift）由 MarkdownInputField 处理发送，这里不处理
+            // Enter 键（无 Shift）处理：如果在列表项中，让 EnterKey 处理；否则由 MarkdownInputField 处理发送
             if (e.key === 'Enter' && !(e.ctrlKey || e.metaKey) && !e.shiftKey) {
+                // 检查当前是否在列表项中
+                var selection1 = markdownEditorRef.current.selection;
+                if (selection1 && Range.isCollapsed(selection1)) {
+                    var _Editor_nodes1 = _sliced_to_array(Editor.nodes(markdownEditorRef.current, {
+                        at: selection1.focus.path,
+                        match: function(n) {
+                            return Element.isElement(n) && n.type === 'list-item';
+                        },
+                        mode: 'lowest'
+                    }), 1), node1 = _Editor_nodes1[0];
+                    if (node1) {
+                        // 在列表项中，让 EnterKey 处理
+                        e.stopPropagation();
+                        e.preventDefault();
+                        enter.run(e);
+                        return;
+                    }
+                }
+                // 不在列表项中，让 MarkdownInputField 处理发送
                 return;
             }
-            var _Editor_nodes1 = _sliced_to_array(Editor.nodes(markdownEditorRef.current, {
+            var _Editor_nodes2 = _sliced_to_array(Editor.nodes(markdownEditorRef.current, {
                 match: function(n) {
                     return Element.isElement(n);
                 },
                 mode: 'lowest'
-            }), 1), node1 = _Editor_nodes1[0];
-            if (!node1) return;
-            if ((node1 === null || node1 === void 0 ? void 0 : (_node_ = node1[0]) === null || _node_ === void 0 ? void 0 : _node_.type) === 'paragraph') {
-                var _Editor_nodes2 = _sliced_to_array(Editor.nodes(markdownEditorRef.current, {
+            }), 1), node2 = _Editor_nodes2[0];
+            if (!node2) return;
+            if ((node2 === null || node2 === void 0 ? void 0 : (_node_ = node2[0]) === null || _node_ === void 0 ? void 0 : _node_.type) === 'paragraph') {
+                var _Editor_nodes3 = _sliced_to_array(Editor.nodes(markdownEditorRef.current, {
                     match: function(n) {
                         return Element.isElement(n) && n.type === 'paragraph';
                     },
                     mode: 'lowest'
-                }), 1), node2 = _Editor_nodes2[0];
-                if (node2 && node2[0].children.length === 1 && !EditorUtils.isDirtLeaf(node2[0].children[0]) && (e.key === 'Backspace' || /^[^\n]$/.test(e.key))) {
-                    var str = Node.string(node2[0]) || '';
+                }), 1), node3 = _Editor_nodes3[0];
+                if (node3 && node3[0].children.length === 1 && !EditorUtils.isDirtLeaf(node3[0].children[0]) && (e.key === 'Backspace' || /^[^\n]$/.test(e.key))) {
+                    var str = Node.string(node3[0]) || '';
                     var codeMatch = str.match(/^```([\w+\-#]+)$/i);
                     if (codeMatch) {} else {
                         var insertMatch = str.match(/^\/([^\n]+)?$/i);
-                        if (insertMatch && !(!Path.hasPrevious(node2[1]) && Node.parent(markdownEditorRef.current, node2[1]).type === 'list-item')) {
+                        if (insertMatch && !(!Path.hasPrevious(node3[1]) && Node.parent(markdownEditorRef.current, node3[1]).type === 'list-item')) {
                             setOpenInsertCompletion === null || setOpenInsertCompletion === void 0 ? void 0 : setOpenInsertCompletion(true);
                             setTimeout(function() {
                                 insertCompletionText$.next(insertMatch[1]);

package/dist/MarkdownEditor/editor/store.d.ts

@@ -204,17 +204,6 @@ export declare class EditorStore {
      * @private
      */
     private _parseAndSetContentWithRAF;
-    /**
-     * 使用 requestAnimationFrame 分批设置内容
-     * 每帧插入一批节点，避免长时间阻塞主线程
-     *
-     * @param allNodes - 所有要插入的节点
-     * @param batchSize - 每帧处理的节点数量
-     * @param onProgress - 进度回调函数
-     * @returns Promise，在所有节点插入完成后 resolve
-     * @private
-     */
-    private _setContentWithRAF;
     /**
      * 按指定分隔符拆分 markdown 内容
      * 保持内容结构的完整性

package/dist/MarkdownEditor/editor/store.js

@@ -648,64 +648,6 @@ export var EditorStoreContext = createContext(null);
                 });
             }
         },
-        {
-            key: "_setContentWithRAF",
-            value: /**
-   * 使用 requestAnimationFrame 分批设置内容
-   * 每帧插入一批节点，避免长时间阻塞主线程
-   *
-   * @param allNodes - 所有要插入的节点
-   * @param batchSize - 每帧处理的节点数量
-   * @param onProgress - 进度回调函数
-   * @returns Promise，在所有节点插入完成后 resolve
-   * @private
-   */ function _setContentWithRAF(allNodes, batchSize, onProgress) {
-                var _this = this;
-                return new Promise(function(resolve, reject) {
-                    var currentIndex = 0;
-                    var totalNodes = allNodes.length;
-                    var rafId = null;
-                    var insertBatch = function() {
-                        try {
-                            var endIndex = Math.min(currentIndex + batchSize, totalNodes);
-                            var batch = allNodes.slice(currentIndex, endIndex);
-                            if (currentIndex === 0) {
-                                // 第一批：清空并插入
-                                _this._editor.current.children = batch;
-                                _this._editor.current.onChange();
-                            } else {
-                                var // 后续批次：追加节点
-                                _this__editor_current_children;
-                                (_this__editor_current_children = _this._editor.current.children).push.apply(_this__editor_current_children, _to_consumable_array(batch));
-                                _this._editor.current.onChange();
-                            }
-                            currentIndex = endIndex;
-                            var progress = currentIndex / totalNodes;
-                            // 直接调用进度回调，避免嵌套 requestAnimationFrame
-                            onProgress === null || onProgress === void 0 ? void 0 : onProgress(progress);
-                            if (currentIndex < totalNodes) {
-                                // 还有节点未处理，继续下一帧
-                                rafId = requestAnimationFrame(insertBatch);
-                            } else {
-                                // 所有节点处理完成
-                                ReactEditor.deselect(_this._editor.current);
-                                rafId = null;
-                                resolve();
-                            }
-                        } catch (error) {
-                            // 清理资源并拒绝 Promise
-                            if (rafId) {
-                                cancelAnimationFrame(rafId);
-                                rafId = null;
-                            }
-                            reject(error);
-                        }
-                    };
-                    // 开始第一帧
-                    rafId = requestAnimationFrame(insertBatch);
-                });
-            }
-        },
         {
             key: "_splitMarkdown",
             value: /**
@@ -952,67 +894,17 @@ export var EditorStoreContext = createContext(null);
    * @param nodeList - 要设置为编辑器内容的节点列表
    */ key: "setContent",
             value: function setContent(nodeList) {
-                var _this = this;
                 var currentChildren = this._editor.current.children;
-                var resultChildren = [];
-                // 逐个比较节点，如果 hash 和 finished 相同就保留旧节点，否则使用新节点
-                for(var i = 0; i < nodeList.length; i++){
-                    var newNode = nodeList[i];
-                    var oldNode = currentChildren[i];
-                    // 如果旧节点不存在，直接使用新节点
-                    if (!oldNode) {
-                        resultChildren.push(newNode);
-                        continue;
-                    }
-                    // 如果 hash 和 finished 都相同，保留旧节点，继续处理下一个
-                    if (this._isNodeEqual(newNode, oldNode)) {
-                        resultChildren.push(oldNode);
-                        continue;
-                    }
-                    // hash 或 finished 不相同，使用新节点替换
-                    resultChildren.push(newNode);
-                }
-                // 使用批处理模式执行所有操作
-                Editor.withoutNormalizing(this._editor.current, function() {
-                    // 先删除多余的节点（从后往前删除，避免索引变化）
-                    if (currentChildren.length > resultChildren.length) {
-                        for(var i = currentChildren.length - 1; i >= resultChildren.length; i--){
-                            Transforms.removeNodes(_this._editor.current, {
-                                at: [
-                                    i
-                                ]
-                            });
-                        }
-                    }
-                    // 然后逐个替换或插入节点（从前往后处理）
-                    for(var i1 = 0; i1 < resultChildren.length; i1++){
-                        var newNode = resultChildren[i1];
-                        var oldNode = currentChildren[i1];
-                        if (!oldNode) {
-                            // 旧节点不存在，插入新节点
-                            Transforms.insertNodes(_this._editor.current, newNode, {
-                                at: [
-                                    i1
-                                ]
-                            });
-                        } else if (oldNode !== newNode) {
-                            // 节点不同，替换节点
-                            _this._replaceNodeAt([
-                                i1
-                            ], newNode);
-                        }
-                    // 如果 oldNode === newNode，说明是同一个对象引用，不需要更新
-                    }
-                });
+                this._editor.current.children = nodeList;
                 this._editor.current.onChange();
                 // 检查最后一个节点是否以换行符结尾
-                var lastNode = resultChildren[resultChildren.length - 1];
+                var lastNode = currentChildren[currentChildren.length - 1];
                 if (lastNode && Text.isText(lastNode)) {
                     var text = Node.string(lastNode);
                     if (!text.endsWith('\n')) {
                         this._editor.current.insertText('\n', {
                             at: [
-                                resultChildren.length - 1
+                                currentChildren.length - 1
                             ]
                         });
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ant-design/agentic-ui",
-  "version": "2.29.8",
+  "version": "2.29.10",
   "description": "面向智能体的 UI 组件库，提供多步推理可视化、工具调用展示、任务执行协同等 Agentic UI 能力",
   "repository": "git@github.com:ant-design/agentic-ui.git",
   "license": "MIT",
@@ -22,12 +22,11 @@
     "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",
     "start": "pnpm run dev",
-    "test": "echo \"Error: no test specified\" ",
+    "test": "vitest --run --exclude \"**/e2e/**\"",
     "test:coverage": "vitest --run --exclude \"**/e2e/**\" --coverage",
     "test:e2e": "playwright test",
     "test:e2e:debug": "playwright test --debug",