@ant-design/agentic-ui 2.29.7 → 2.29.8

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

@@ -90,6 +90,7 @@ function _unsupported_iterable_to_array(o, minLen) {
 }
 import { Editor, Element, Node, Path, Point, Range, Transforms } from "slate";
 import { EditorUtils } from "../../utils/editorUtils";
+import { isListType } from "../withListsPlugin";
 export var BackspaceKey = /*#__PURE__*/ function() {
     "use strict";
     function BackspaceKey(editor) {
@@ -166,67 +167,124 @@ 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 listPath = Path.parent(parent1[1]);
-                            var listNode = Editor.node(this.editor, listPath);
+                            var listPath1 = Path.parent(parent1[1]);
+                            var listNode = Editor.node(this.editor, listPath1);
                             var currentItemIndex = parent1[1][parent1[1].length - 1];
                             var isLastItem = currentItemIndex === listNode[0].children.length - 1;
                             if (isLastItem) {
                                 // 如果是最后一个项目，删除list-item并替换成paragraph
-                                Transforms.delete(this.editor, {
+                                // 使用 removeNodes 删除元素节点
+                                Transforms.removeNodes(this.editor, {
                                     at: parent1[1]
                                 });
-                                Transforms.insertNodes(this.editor, {
-                                    type: 'paragraph',
-                                    children: [
-                                        {
-                                            text: ''
-                                        }
-                                    ]
-                                }, {
-                                    at: parent1[1],
-                                    select: true
-                                });
+                                // 如果列表为空，删除列表容器
+                                var updatedList1 = Node.get(this.editor, listPath1);
+                                if (isListType(updatedList1) && updatedList1.children.length === 0) {
+                                    Transforms.removeNodes(this.editor, {
+                                        at: listPath1
+                                    });
+                                    // 在列表位置插入 paragraph
+                                    Transforms.insertNodes(this.editor, {
+                                        type: 'paragraph',
+                                        children: [
+                                            {
+                                                text: ''
+                                            }
+                                        ]
+                                    }, {
+                                        at: listPath1,
+                                        select: true
+                                    });
+                                } else {
+                                    // 在删除的位置插入 paragraph
+                                    Transforms.insertNodes(this.editor, {
+                                        type: 'paragraph',
+                                        children: [
+                                            {
+                                                text: ''
+                                            }
+                                        ]
+                                    }, {
+                                        at: parent1[1],
+                                        select: true
+                                    });
+                                }
                             } else {
-                                // 如果不是最后一个项目，拆分列表
-                                var remainingItems = listNode[0].children.slice(currentItemIndex + 1);
-                                // 删除当前item之后的所有items
+                                // 如果不是最后一个项目，删除当前item和之后的所有items
+                                // 先删除后面的 items（从后往前删除，避免索引变化）
                                 for(var i = listNode[0].children.length - 1; i > currentItemIndex; i--){
-                                    Transforms.delete(this.editor, {
-                                        at: _to_consumable_array(listPath).concat([
+                                    Transforms.removeNodes(this.editor, {
+                                        at: _to_consumable_array(listPath1).concat([
                                             i
                                         ])
                                     });
                                 }
                                 // 删除当前item
-                                Transforms.delete(this.editor, {
+                                Transforms.removeNodes(this.editor, {
                                     at: parent1[1]
                                 });
-                                // 插入paragraph
-                                var insertPath = Path.next(listPath);
-                                Transforms.insertNodes(this.editor, {
-                                    type: 'paragraph',
-                                    children: [
-                                        {
-                                            text: ''
-                                        }
-                                    ]
-                                }, {
-                                    at: insertPath,
-                                    select: true
-                                });
-                                // 如果有剩余的items，创建新的列表
-                                if (remainingItems.length > 0) {
-                                    var newListPath = Path.next(insertPath);
+                                // 检查列表是否为空，如果为空则删除列表容器
+                                var updatedList2 = Node.get(this.editor, listPath1);
+                                if (isListType(updatedList2) && updatedList2.children.length === 0) {
+                                    // 列表为空，删除列表容器
+                                    Transforms.removeNodes(this.editor, {
+                                        at: listPath1
+                                    });
+                                    // 在列表位置插入 paragraph
+                                    Transforms.insertNodes(this.editor, {
+                                        type: 'paragraph',
+                                        children: [
+                                            {
+                                                text: ''
+                                            }
+                                        ]
+                                    }, {
+                                        at: listPath1,
+                                        select: true
+                                    });
+                                } else {
+                                    // 列表还有前面的 items，保持列表
+                                    // 在列表后插入 paragraph
+                                    var insertPath = Path.next(listPath1);
                                     Transforms.insertNodes(this.editor, {
-                                        type: listNode[0].type,
-                                        children: remainingItems
+                                        type: 'paragraph',
+                                        children: [
+                                            {
+                                                text: ''
+                                            }
+                                        ]
                                     }, {
-                                        at: newListPath
+                                        at: insertPath,
+                                        select: true
                                     });
                                 }
                             }

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

@@ -8,5 +8,19 @@ export declare class TabKey {
     constructor(editor: Editor);
     run(e: React.KeyboardEvent): void;
     private tableCell;
+    /**
+     * 处理列表项的 Tab/Shift+Tab 键
+     *
+     * Tab: 增加缩进（将当前 list-item 移动到前一个 list-item 的子列表中）
+     * Shift+Tab: 减少缩进（将当前 list-item 提升一级）
+     */
     private listItem;
+    /**
+     * 增加缩进：将当前 list-item 移动到前一个 list-item 的子列表中
+     */
+    private indentListItem;
+    /**
+     * 减少缩进：将当前 list-item 提升一级
+     */
+    private outdentListItem;
 }

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

@@ -89,6 +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";
 /**
  * TabKey 类用于处理编辑器中的 Tab 键事件。
  */ export var TabKey = /*#__PURE__*/ function() {
@@ -176,7 +177,7 @@ import { Editor, Element, Node, Path, Point, Range, Text, Transforms } from "sla
                     } else if (e.shiftKey) {
                         var _Editor_nodes3 = _sliced_to_array(Editor.nodes(this.editor, {
                             match: function(n) {
-                                return n.type === 'list';
+                                return isListType(n);
                             }
                         }), 1), node1 = _Editor_nodes3[0];
                         if (node1) {
@@ -232,102 +233,128 @@ import { Editor, Element, Node, Path, Point, Range, Text, Transforms } from "sla
         },
         {
             key: "listItem",
-            value: function listItem(node, e) {
+            value: /**
+   * 处理列表项的 Tab/Shift+Tab 键
+   * 
+   * Tab: 增加缩进（将当前 list-item 移动到前一个 list-item 的子列表中）
+   * Shift+Tab: 减少缩进（将当前 list-item 提升一级）
+   */ function listItem(node, e) {
+                var listItemPath = Path.parent(node[1]);
+                var listItem = Node.get(this.editor, listItemPath);
+                if (!Element.isElement(listItem) || listItem.type !== 'list-item') {
+                    return false;
+                }
+                var listPath = Path.parent(listItemPath);
+                var list = Node.get(this.editor, listPath);
+                if (!isListType(list)) {
+                    return false;
+                }
                 if (e.shiftKey) {
-                    var li = Editor === null || Editor === void 0 ? void 0 : Editor.node(this.editor, Path.parent(node[1]));
-                    var ul = Editor === null || Editor === void 0 ? void 0 : Editor.node(this.editor, Path.parent(li[1]));
-                    var container = Editor === null || Editor === void 0 ? void 0 : Editor.node(this.editor, Path.parent(ul[1]));
-                    if (!Path.hasPrevious(ul[1]) && Node.parent(this.editor, ul[1]).type === 'list-item') return true;
-                    var top = !Path.hasPrevious(node[1]);
-                    var first = !Path.hasPrevious(li[1]);
-                    if (top) {
-                        Transforms.liftNodes(this.editor, {
-                            at: li[1]
-                        });
-                        if (container[0].type === 'list-item') {
-                            var movePath = first ? ul[1] : Path.next(ul[1]);
-                            Transforms.moveNodes(this.editor, {
-                                at: movePath,
-                                to: Path.next(container[1])
-                            });
-                            var start = li[0].children.length;
-                            while(Editor.hasPath(this.editor, movePath)){
-                                Transforms.moveNodes(this.editor, {
-                                    at: movePath,
-                                    to: _to_consumable_array(Path.next(container[1])).concat([
-                                        start
-                                    ])
-                                });
-                                start++;
-                            }
-                        } else {
-                            Transforms.unwrapNodes(this.editor, {
-                                at: first ? ul[1] : Path.next(ul[1])
-                            });
-                        }
-                    } else {
-                        var move = li[0].children.length - node[1].slice().pop() - 1;
-                        Transforms.liftNodes(this.editor, {
-                            at: {
-                                anchor: Editor.start(this.editor, node[1]),
-                                focus: Editor.end(this.editor, li[1])
-                            }
-                        });
-                        var nextPath = Path.next(li[1]);
-                        var lastIndex = nextPath.slice().pop();
-                        Transforms.liftNodes(this.editor, {
-                            at: {
-                                anchor: {
-                                    path: nextPath,
-                                    offset: 1
-                                },
-                                focus: {
-                                    path: nextPath.slice(0, -1).concat([
-                                        lastIndex + move
-                                    ]),
-                                    offset: 0
-                                }
-                            }
+                    // Shift+Tab: 减少缩进
+                    return this.outdentListItem(listItemPath, listPath);
+                } else {
+                    // Tab: 增加缩进
+                    return this.indentListItem(listItemPath);
+                }
+            }
+        },
+        {
+            key: "indentListItem",
+            value: /**
+   * 增加缩进：将当前 list-item 移动到前一个 list-item 的子列表中
+   */ function indentListItem(listItemPath) {
+                // 检查是否是第一个 list-item（第一行按 Tab 应该无效）
+                if (!Path.hasPrevious(listItemPath)) {
+                    return false;
+                }
+                var previousListItemPath = Path.previous(listItemPath);
+                var previousListItem = Node.get(this.editor, previousListItemPath);
+                if (!Element.isElement(previousListItem) || previousListItem.type !== 'list-item') {
+                    return false;
+                }
+                // 检查前一个 list-item 的最后一个子节点是否为列表
+                var lastChildIndex = previousListItem.children.length - 1;
+                var lastChild = previousListItem.children[lastChildIndex];
+                if (isListType(lastChild)) {
+                    // 如果最后一个子节点是列表，直接将当前项移动到该列表中
+                    var targetListPath = _to_consumable_array(previousListItemPath).concat([
+                        lastChildIndex
+                    ]);
+                    var targetList = Node.get(this.editor, targetListPath);
+                    if (isListType(targetList)) {
+                        var targetIndex = targetList.children.length;
+                        Transforms.moveNodes(this.editor, {
+                            at: listItemPath,
+                            to: _to_consumable_array(targetListPath).concat([
+                                targetIndex
+                            ])
                         });
+                        return true;
                     }
-                    return true;
                 } else {
-                    var listItem = Editor.parent(this.editor, node[1]);
-                    var list = Editor.parent(this.editor, listItem[1]);
-                    if (!Node.string(node[0]) && Path.hasPrevious(listItem[1]) && listItem[0].children.length === 1) {
+                    // 如果最后一个子节点不是列表，需要创建一个新的列表
+                    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([
+                            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));
+                    return true;
+                }
+                return false;
+            }
+        },
+        {
+            key: "outdentListItem",
+            value: /**
+   * 减少缩进：将当前 list-item 提升一级
+   */ function outdentListItem(listItemPath, listPath) {
+                // 检查当前 list 的父节点
+                var listParent = Editor.parent(this.editor, listPath);
+                // 如果父节点是 list-item，说明在嵌套列表中，可以提升
+                if (Element.isElement(listParent[0]) && listParent[0].type === 'list-item') {
+                    var parentListItemPath = listParent[1];
+                    // 检查是否是父列表的第一个 list-item
+                    var isFirstInParentList = !Path.hasPrevious(listPath);
+                    if (isFirstInParentList && !Path.hasPrevious(parentListItemPath)) {
+                        // 如果是最顶层的第一个项，不能提升
+                        return false;
+                    }
+                    // 使用 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: listItem[1]
-                        });
-                        var pre = Path.previous(listItem[1]);
-                        var _Node_children = _sliced_to_array(Node.children(this.editor, pre, {
-                            reverse: true
-                        }), 1), next = _Node_children[0];
-                        Transforms.insertNodes(this.editor, {
-                            type: 'list',
-                            order: list[0].order,
-                            task: list[0].task,
-                            children: [
-                                {
-                                    type: 'list-item',
-                                    checked: Node.get(this.editor, pre).checked,
-                                    children: [
-                                        {
-                                            type: 'paragraph',
-                                            children: [
-                                                {
-                                                    text: ''
-                                                }
-                                            ]
-                                        }
-                                    ]
-                                }
-                            ]
-                        }, {
-                            at: Path.next(next[1]),
-                            select: true
+                            at: listPath
                         });
-                        return true;
                     }
+                    return true;
+                } else {
+                    // 已经是最顶层，不能提升
                     return false;
                 }
             }

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

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

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

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

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

@@ -3,23 +3,28 @@ export declare const ELEMENT_TAGS: {
     BLOCKQUOTE: () => {
         type: string;
     };
-    H1: () => {
+    H1: (el: HTMLElement) => {
+        align?: string | undefined;
         type: string;
         level: number;
     };
-    H2: () => {
+    H2: (el: HTMLElement) => {
+        align?: string | undefined;
         type: string;
         level: number;
     };
-    H3: () => {
+    H3: (el: HTMLElement) => {
+        align?: string | undefined;
         type: string;
         level: number;
     };
-    H4: () => {
+    H4: (el: HTMLElement) => {
+        align?: string | undefined;
         type: string;
         level: number;
     };
-    H5: () => {
+    H5: (el: HTMLElement) => {
+        align?: string | undefined;
         type: string;
         level: number;
     };
@@ -51,7 +56,8 @@ export declare const ELEMENT_TAGS: {
         type: string;
         order: boolean;
     };
-    P: () => {
+    P: (el: HTMLElement) => {
+        align?: string | undefined;
         type: string;
     };
     PRE: () => {