@ant-design/agentic-ui 2.30.22 → 2.30.23

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

@@ -202,15 +202,37 @@ export var EnterKey = /*#__PURE__*/ function() {
         {
             key: "empty",
             value: function empty(e, path) {
+                var _this = this;
                 var _Editor_parent = _sliced_to_array(Editor.parent(this.editor, path), 2), parent = _Editor_parent[0], parentPath = _Editor_parent[1];
                 if (parent.type === 'blockquote') {
                     if (!Path.hasPrevious(path)) {
                         var hashNext = Editor.hasPath(this.editor, Path.next(path));
                         if (!hashNext) {
-                            Transforms.delete(this.editor, {
-                                at: parentPath
+                            Editor.withoutNormalizing(this.editor, function() {
+                                Transforms.delete(_this.editor, {
+                                    at: parentPath
+                                });
+                                Transforms.insertNodes(_this.editor, {
+                                    type: 'paragraph',
+                                    children: [
+                                        {
+                                            text: ''
+                                        }
+                                    ]
+                                }, {
+                                    at: parentPath,
+                                    select: true
+                                });
                             });
-                            Transforms.insertNodes(this.editor, {
+                            e.preventDefault();
+                        }
+                    }
+                    if (!Editor.hasPath(this.editor, Path.next(path))) {
+                        Editor.withoutNormalizing(this.editor, function() {
+                            Transforms.delete(_this.editor, {
+                                at: path
+                            });
+                            Transforms.insertNodes(_this.editor, {
                                 type: 'paragraph',
                                 children: [
                                     {
@@ -218,26 +240,9 @@ export var EnterKey = /*#__PURE__*/ function() {
                                     }
                                 ]
                             }, {
-                                at: parentPath,
+                                at: Path.next(parentPath),
                                 select: true
                             });
-                            e.preventDefault();
-                        }
-                    }
-                    if (!Editor.hasPath(this.editor, Path.next(path))) {
-                        Transforms.delete(this.editor, {
-                            at: path
-                        });
-                        Transforms.insertNodes(this.editor, {
-                            type: 'paragraph',
-                            children: [
-                                {
-                                    text: ''
-                                }
-                            ]
-                        }, {
-                            at: Path.next(parentPath),
-                            select: true
                         });
                         e.preventDefault();
                     }
@@ -247,65 +252,69 @@ export var EnterKey = /*#__PURE__*/ function() {
                     var realEmpty = parent.children.length === 1;
                     if (ul.children.length === 1 && realEmpty) {
                         e.preventDefault();
-                        Transforms.delete(this.editor, {
-                            at: ulPath
-                        });
-                        Transforms.insertNodes(this.editor, EditorUtils.p, {
-                            at: ulPath,
-                            select: true
+                        Editor.withoutNormalizing(this.editor, function() {
+                            Transforms.delete(_this.editor, {
+                                at: ulPath
+                            });
+                            Transforms.insertNodes(_this.editor, EditorUtils.p, {
+                                at: ulPath,
+                                select: true
+                            });
                         });
                         return;
                     }
                     if (realEmpty) {
                         e.preventDefault();
-                        if (!Path.hasPrevious(parentPath)) {
-                            Transforms.delete(this.editor, {
-                                at: parentPath
-                            });
-                            Transforms.insertNodes(this.editor, EditorUtils.p, {
-                                at: ulPath,
-                                select: true
-                            });
-                        } else if (!Editor.hasPath(this.editor, Path.next(parentPath))) {
-                            Transforms.delete(this.editor, {
-                                at: parentPath
-                            });
-                            Transforms.insertNodes(this.editor, EditorUtils.p, {
-                                at: Path.next(ulPath),
-                                select: true
-                            });
-                        } else {
-                            Transforms.liftNodes(this.editor, {
-                                at: parentPath
-                            });
-                            Transforms.delete(this.editor, {
-                                at: Path.next(ulPath)
-                            });
-                            Transforms.insertNodes(this.editor, EditorUtils.p, {
-                                at: Path.next(ulPath),
-                                select: true
-                            });
-                        }
+                        Editor.withoutNormalizing(this.editor, function() {
+                            if (!Path.hasPrevious(parentPath)) {
+                                Transforms.delete(_this.editor, {
+                                    at: parentPath
+                                });
+                                Transforms.insertNodes(_this.editor, EditorUtils.p, {
+                                    at: ulPath,
+                                    select: true
+                                });
+                            } else if (!Editor.hasPath(_this.editor, Path.next(parentPath))) {
+                                Transforms.delete(_this.editor, {
+                                    at: parentPath
+                                });
+                                Transforms.insertNodes(_this.editor, EditorUtils.p, {
+                                    at: Path.next(ulPath),
+                                    select: true
+                                });
+                            } else {
+                                Transforms.liftNodes(_this.editor, {
+                                    at: parentPath
+                                });
+                                Transforms.delete(_this.editor, {
+                                    at: Path.next(ulPath)
+                                });
+                                Transforms.insertNodes(_this.editor, EditorUtils.p, {
+                                    at: Path.next(ulPath),
+                                    select: true
+                                });
+                            }
+                        });
                     } else {
                         if (!Editor.hasPath(this.editor, Path.next(path))) {
                             e.preventDefault();
-                            Transforms.delete(this.editor, {
-                                at: path
-                            });
-                            Transforms.insertNodes(this.editor, {
-                                type: 'list-item',
-                                checked: typeof parent.checked === 'boolean' ? false : undefined,
-                                children: [
-                                    EditorUtils.p
-                                ]
-                            }, {
-                                at: Path.next(parentPath),
-                                select: true
+                            Editor.withoutNormalizing(this.editor, function() {
+                                Transforms.delete(_this.editor, {
+                                    at: path
+                                });
+                                Transforms.insertNodes(_this.editor, {
+                                    type: 'list-item',
+                                    checked: typeof parent.checked === 'boolean' ? false : undefined,
+                                    children: [
+                                        EditorUtils.p
+                                    ]
+                                }, {
+                                    at: Path.next(parentPath),
+                                    select: true
+                                });
                             });
                         } else if (!Path.hasPrevious(path)) {
                             e.preventDefault();
-                            // 在列表项开头按回车时，只创建新的空列表项，不移动任何节点
-                            // 这样可以避免将嵌套列表或其他节点移动到新列表项内部，导致缩进
                             Transforms.insertNodes(this.editor, {
                                 type: 'list-item',
                                 checked: typeof parent.checked === 'boolean' ? false : undefined,
@@ -391,6 +400,7 @@ export var EnterKey = /*#__PURE__*/ function() {
         {
             key: "head",
             value: function head(el, path, sel) {
+                var _this = this;
                 var start = Range.start(sel);
                 var elStart = Editor.start(this.editor, path);
                 if (Point.equals(start, elStart)) {
@@ -420,28 +430,30 @@ export var EnterKey = /*#__PURE__*/ function() {
                             select: true
                         });
                     } else {
-                        var _fragment_;
                         var fragment = Node.fragment(this.editor, {
                             anchor: end,
                             focus: elEnd
                         });
-                        Transforms.delete(this.editor, {
-                            at: {
-                                anchor: start,
-                                focus: elEnd
-                            }
-                        });
-                        Transforms.insertNodes(this.editor, {
-                            type: 'paragraph',
-                            children: ((_fragment_ = fragment[0]) === null || _fragment_ === void 0 ? void 0 : _fragment_.children) || [
-                                {
-                                    text: ''
+                        Editor.withoutNormalizing(this.editor, function() {
+                            var _fragment_;
+                            Transforms.delete(_this.editor, {
+                                at: {
+                                    anchor: start,
+                                    focus: elEnd
                                 }
-                            ]
-                        }, {
-                            at: Path.next(path)
+                            });
+                            Transforms.insertNodes(_this.editor, {
+                                type: 'paragraph',
+                                children: ((_fragment_ = fragment[0]) === null || _fragment_ === void 0 ? void 0 : _fragment_.children) || [
+                                    {
+                                        text: ''
+                                    }
+                                ]
+                            }, {
+                                at: Path.next(path)
+                            });
+                            Transforms.select(_this.editor, Editor.start(_this.editor, Path.next(path)));
                         });
-                        Transforms.select(this.editor, Editor.start(this.editor, Path.next(path)));
                     }
                 }
                 return true;
@@ -450,6 +462,7 @@ export var EnterKey = /*#__PURE__*/ function() {
         {
             key: "paragraph",
             value: function paragraph(e, node, sel) {
+                var _this = this;
                 var parent = Editor.parent(this.editor, node[1]);
                 var end = Editor.end(this.editor, node[1]);
                 if (Point.equals(end, sel.focus)) {
@@ -502,12 +515,14 @@ export var EnterKey = /*#__PURE__*/ function() {
                     var isListWithSingleEmptyItem = listNode.children.length === 1 && Node.string(node[0]) === '' && !Path.hasPrevious(listItemPath);
                     if (isListWithSingleEmptyItem) {
                         e.preventDefault();
-                        Transforms.removeNodes(this.editor, {
-                            at: listPath
-                        });
-                        Transforms.insertNodes(this.editor, EditorUtils.p, {
-                            at: listPath,
-                            select: true
+                        Editor.withoutNormalizing(this.editor, function() {
+                            Transforms.removeNodes(_this.editor, {
+                                at: listPath
+                            });
+                            Transforms.insertNodes(_this.editor, EditorUtils.p, {
+                                at: listPath,
+                                select: true
+                            });
                         });
                         return true;
                     }
@@ -517,25 +532,25 @@ export var EnterKey = /*#__PURE__*/ function() {
                                 text: ''
                             }
                         ] : EditorUtils.cutText(this.editor, sel.focus);
-                        Transforms.insertNodes(this.editor, {
-                            type: 'paragraph',
-                            children: text || ' '
-                        }, {
-                            at: Path.next(node[1])
-                        });
-                        if (!Point.equals(end, sel.focus)) {
-                            Transforms.delete(this.editor, {
-                                at: {
-                                    anchor: sel.focus,
-                                    focus: end
-                                }
+                        Editor.withoutNormalizing(this.editor, function() {
+                            Transforms.insertNodes(_this.editor, {
+                                type: 'paragraph',
+                                children: text || ' '
+                            }, {
+                                at: Path.next(node[1])
                             });
-                        }
-                        if (Editor.hasPath(this.editor, Path.next(node[1]))) {
-                            Transforms.select(this.editor, Editor.start(this.editor, Path.next(node[1])));
-                        } else {
-                            Transforms.select(this.editor, Editor.start(this.editor, Path.next(node[1])));
-                        }
+                            if (!Point.equals(end, sel.focus)) {
+                                Transforms.delete(_this.editor, {
+                                    at: {
+                                        anchor: sel.focus,
+                                        focus: end
+                                    }
+                                });
+                            }
+                            if (Editor.hasPath(_this.editor, Path.next(node[1]))) {
+                                Transforms.select(_this.editor, Editor.start(_this.editor, Path.next(node[1])));
+                            }
+                        });
                         e.preventDefault();
                         return true;
                     } else {
@@ -564,38 +579,39 @@ export var EnterKey = /*#__PURE__*/ function() {
                                 text: ''
                             }
                         ] : EditorUtils.cutText(this.editor, sel.focus);
-                        Transforms.insertNodes(this.editor, {
-                            type: 'list-item',
-                            children: [
-                                {
-                                    type: 'paragraph',
-                                    children: text1 || [
-                                        {
-                                            text: ''
-                                        }
-                                    ]
-                                }
-                            ],
-                            checked: checked
-                        }, {
-                            at: Path.next(parent[1])
-                        });
-                        if (!Point.equals(sel.anchor, Editor.end(this.editor, node[1]))) {
-                            Transforms.delete(this.editor, {
-                                at: {
-                                    anchor: sel.anchor,
-                                    focus: Editor.end(this.editor, node[1])
-                                }
+                        Editor.withoutNormalizing(this.editor, function() {
+                            Transforms.insertNodes(_this.editor, {
+                                type: 'list-item',
+                                children: [
+                                    {
+                                        type: 'paragraph',
+                                        children: text1 || [
+                                            {
+                                                text: ''
+                                            }
+                                        ]
+                                    }
+                                ],
+                                checked: checked
+                            }, {
+                                at: Path.next(parent[1])
                             });
-                        }
-                        if (Point.equals(sel.anchor, Editor.start(this.editor, node[1])) && Node.string(Node.get(this.editor, node[1])) !== '') {
-                            EditorUtils.clearMarks(this.editor);
-                        }
-                        if (Editor.start(this.editor, Path.next(parent[1]))) {
-                            Transforms.select(this.editor, Editor.start(this.editor, Path.next(parent[1])));
-                        }
-                        // 不再移动任何节点到新列表项内部，避免导致新列表项被缩进
-                        // 嵌套列表应该保留在原列表项中
+                            if (!Point.equals(sel.anchor, Editor.end(_this.editor, node[1]))) {
+                                Transforms.delete(_this.editor, {
+                                    at: {
+                                        anchor: sel.anchor,
+                                        focus: Editor.end(_this.editor, node[1])
+                                    }
+                                });
+                            }
+                            if (Point.equals(sel.anchor, Editor.start(_this.editor, node[1])) && Node.string(Node.get(_this.editor, node[1])) !== '') {
+                                EditorUtils.clearMarks(_this.editor);
+                            }
+                            var nextParentPath = Path.next(parent[1]);
+                            if (Editor.hasPath(_this.editor, nextParentPath)) {
+                                Transforms.select(_this.editor, Editor.start(_this.editor, nextParentPath));
+                            }
+                        });
                         return true;
                     }
                 }

package/dist/MarkdownEditor/editor/plugins/hotKeyCommands/match.d.ts

@@ -2,7 +2,8 @@ import React from 'react';
 import { Editor } from 'slate';
 export declare class MatchKey {
     private readonly editorRef;
-    constructor(editorRef: React.MutableRefObject<Editor | null>);
+    private readonly isMatchInputToNodeEnabled;
+    constructor(editorRef: React.MutableRefObject<Editor | null>, isMatchInputToNodeEnabled?: () => boolean);
     private createParams;
     run(e: React.KeyboardEvent): boolean;
 }

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

@@ -85,9 +85,14 @@ import { TextMatchNodes } from "../elements";
 export var MatchKey = /*#__PURE__*/ function() {
     "use strict";
     function MatchKey(editorRef) {
+        var isMatchInputToNodeEnabled = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : function() {
+            return false;
+        };
         _class_call_check(this, MatchKey);
         _define_property(this, "editorRef", void 0);
+        _define_property(this, "isMatchInputToNodeEnabled", void 0);
         this.editorRef = editorRef;
+        this.isMatchInputToNodeEnabled = isMatchInputToNodeEnabled;
     }
     _create_class(MatchKey, [
         {
@@ -109,21 +114,35 @@ export var MatchKey = /*#__PURE__*/ function() {
                 var _node_;
                 var editor = this.editorRef.current;
                 if (!editor) return false;
-                var _Editor_nodes = _sliced_to_array(Editor.nodes(editor, {
+                var sel = editor.selection;
+                if (!sel || !Range.isCollapsed(sel)) return false;
+                var nodesResult = Editor.nodes(editor, {
+                    at: sel.anchor,
                     match: function match(n) {
                         return Element.isElement(n);
                     },
                     mode: 'lowest'
-                }), 1), node = _Editor_nodes[0];
+                });
+                var node;
+                if (Array.isArray(nodesResult) && nodesResult.length > 0) {
+                    node = nodesResult[0];
+                } else {
+                    var iter = nodesResult;
+                    if (iter && typeof iter.next === 'function') {
+                        var first = iter.next();
+                        node = first.done ? undefined : first.value;
+                    }
+                }
                 if (!node || [
                     'code'
                 ].includes(node === null || node === void 0 ? void 0 : (_node_ = node[0]) === null || _node_ === void 0 ? void 0 : _node_.type)) return false;
-                var sel = editor.selection;
-                if (!sel || !Range.isCollapsed(sel)) return false;
                 var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                 try {
                     for(var _iterator = TextMatchNodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                         var n = _step.value;
+                        if (n.gatedByMatchInputToNode && !this.isMatchInputToNodeEnabled()) {
+                            continue;
+                        }
                         if (_type_of(n.matchKey) === 'object' ? n.matchKey.test(e.key) : n.matchKey === e.key) {
                             if (n.checkAllow && !n.checkAllow({
                                 editor: editor,

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

@@ -103,6 +103,7 @@ import { getListType, isListType } from "../withListsPlugin";
         {
             key: "run",
             value: function run(e) {
+                var _this = this;
                 var sel = this.editor.selection;
                 if (!sel) return;
                 e.preventDefault();
@@ -182,15 +183,19 @@ import { getListType, isListType } from "../withListsPlugin";
                         }), 1), node1 = _Editor_nodes3[0];
                         if (node1) {
                             var _Range_edges1 = _sliced_to_array(Range.edges(sel), 2), start1 = _Range_edges1[0], end1 = _Range_edges1[1];
-                            var anchor = start1.path.join(',').startsWith(node1[1].join(',')) ? start1 : Editor.start(this.editor, node1[1]);
-                            var focus = end1.path.join(',').startsWith(node1[1].join(',')) ? end1 : Editor.end(this.editor, node1[1]);
-                            Transforms.liftNodes(this.editor, {
-                                at: {
-                                    anchor: anchor,
-                                    focus: focus
-                                }
+                            var isStartInNode = Path.isDescendant(start1.path, node1[1]) || Path.equals(start1.path, node1[1]);
+                            var isEndInNode = Path.isDescendant(end1.path, node1[1]) || Path.equals(end1.path, node1[1]);
+                            var anchor = isStartInNode ? start1 : Editor.start(this.editor, node1[1]);
+                            var focus = isEndInNode ? end1 : Editor.end(this.editor, node1[1]);
+                            Editor.withoutNormalizing(this.editor, function() {
+                                Transforms.liftNodes(_this.editor, {
+                                    at: {
+                                        anchor: anchor,
+                                        focus: focus
+                                    }
+                                });
+                                Transforms.liftNodes(_this.editor);
                             });
-                            Transforms.liftNodes(this.editor);
                         } else {
                             Transforms.liftNodes(this.editor);
                         }
@@ -263,6 +268,7 @@ import { getListType, isListType } from "../withListsPlugin";
             value: /**
    * 增加缩进：将当前 list-item 移动到前一个 list-item 的子列表中
    */ function indentListItem(listItemPath) {
+                var _this = this;
                 // 检查是否是第一个 list-item（第一行按 Tab 应该无效）
                 if (!Path.hasPrevious(listItemPath)) {
                     return false;
@@ -292,34 +298,31 @@ import { getListType, isListType } from "../withListsPlugin";
                         return true;
                     }
                 } else {
-                    // 如果最后一个子节点不是列表，需要创建一个新的列表
                     var listType = getListType();
                     var currentListItem = Node.get(this.editor, listItemPath);
-                    // 先创建新的列表，包含当前 list-item
                     var newList = {
                         type: listType,
                         children: [
                             currentListItem
                         ]
                     };
-                    // 将当前项移动到新列表中
-                    Transforms.removeNodes(this.editor, {
-                        at: listItemPath
-                    });
-                    Transforms.insertNodes(this.editor, newList, {
-                        at: _to_consumable_array(previousListItemPath).concat([
+                    Editor.withoutNormalizing(this.editor, function() {
+                        Transforms.removeNodes(_this.editor, {
+                            at: listItemPath
+                        });
+                        Transforms.insertNodes(_this.editor, newList, {
+                            at: _to_consumable_array(previousListItemPath).concat([
+                                previousListItem.children.length
+                            ])
+                        });
+                        var newListPath = _to_consumable_array(previousListItemPath).concat([
                             previousListItem.children.length
-                        ])
+                        ]);
+                        var newListItemPath = _to_consumable_array(newListPath).concat([
+                            0
+                        ]);
+                        Transforms.select(_this.editor, Editor.start(_this.editor, newListItemPath));
                     });
-                    // 更新路径，因为节点已移动
-                    var newListPath = _to_consumable_array(previousListItemPath).concat([
-                        previousListItem.children.length
-                    ]);
-                    var newListItemPath = _to_consumable_array(newListPath).concat([
-                        0
-                    ]);
-                    // 选中新位置
-                    Transforms.select(this.editor, Editor.start(this.editor, newListItemPath));
                     return true;
                 }
                 return false;
@@ -330,6 +333,7 @@ import { getListType, isListType } from "../withListsPlugin";
             value: /**
    * 减少缩进：将当前 list-item 提升一级
    */ function outdentListItem(listItemPath, listPath) {
+                var _this = this;
                 // 检查当前 list 的父节点
                 var listParent = Editor.parent(this.editor, listPath);
                 // 如果父节点是 list-item，说明在嵌套列表中，可以提升
@@ -341,17 +345,17 @@ import { getListType, isListType } from "../withListsPlugin";
                         // 如果是最顶层的第一个项，不能提升
                         return false;
                     }
-                    // 使用 liftNodes 提升当前 list-item
-                    Transforms.liftNodes(this.editor, {
-                        at: listItemPath
-                    });
-                    // 如果提升后，原列表为空，需要删除空列表
-                    var updatedList = Node.get(this.editor, listPath);
-                    if (isListType(updatedList) && Node.string(updatedList).trim() === '') {
-                        Transforms.removeNodes(this.editor, {
-                            at: listPath
+                    Editor.withoutNormalizing(this.editor, function() {
+                        Transforms.liftNodes(_this.editor, {
+                            at: listItemPath
                         });
-                    }
+                        var updatedList = Node.get(_this.editor, listPath);
+                        if (isListType(updatedList) && Node.string(updatedList).trim() === '') {
+                            Transforms.removeNodes(_this.editor, {
+                                at: listPath
+                            });
+                        }
+                    });
                     return true;
                 } else {
                     // 已经是最顶层，不能提升