@ant-design/agentic-ui 2.29.7 → 2.29.8

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

@@ -0,0 +1,299 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    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, Node, Path, Range, Transforms } from "slate";
+import { hasRange } from "./utils";
+/**
+ * 处理代码和标签相关节点的操作
+ *
+ * @param editor - Slate编辑器实例
+ * @param operation - 要处理的操作
+ * @param apply - 原始的apply函数
+ * @returns 如果操作被处理则返回true，否则返回false
+ *
+ * @description
+ * 处理以下代码和标签相关操作:
+ * - 删除文本 (remove_text)，处理特殊触发文本和空标签
+ * - 删除节点 (remove_node)，处理代码块周围的空格
+ * - 插入文本 (insert_text)，处理代码块中的空格插入
+ */ var handleCodeTagOperation = function(editor, operation, apply) {
+    if (operation.type === 'remove_text') {
+        var currentNode = Node.get(editor, operation.path);
+        if (currentNode === null || currentNode === void 0 ? void 0 : currentNode.tag) {
+            var _currentNode_text;
+            // 处理空标签的删除
+            if (((_currentNode_text = currentNode.text) === null || _currentNode_text === void 0 ? void 0 : _currentNode_text.trim()) === '') {
+                Editor.withoutNormalizing(editor, function() {
+                    Transforms.setNodes(editor, {
+                        tag: false,
+                        code: false,
+                        text: ' ',
+                        triggerText: undefined
+                    }, {
+                        at: operation.path
+                    });
+                });
+                return true;
+            }
+            if (currentNode.text === operation.text) {
+                Editor.withoutNormalizing(editor, function() {
+                    Transforms.removeNodes(editor, {
+                        at: operation.path
+                    });
+                    Transforms.insertNodes(editor, _object_spread_props(_object_spread({}, currentNode), {
+                        tag: true,
+                        code: true,
+                        text: ' '
+                    }), {
+                        at: operation.path,
+                        select: true
+                    });
+                });
+                return true;
+            }
+            // 光标在 tag 内部，执行原始的删除操作
+            apply(operation);
+            return true;
+        }
+    }
+    if (operation.type === 'insert_text') {
+        var _editor_selection;
+        var currentNode1 = Node.get(editor, operation.path);
+        if ((currentNode1 === null || currentNode1 === void 0 ? void 0 : currentNode1.tag) && operation.text === ' ' && ((_editor_selection = editor.selection) === null || _editor_selection === void 0 ? void 0 : _editor_selection.focus.offset) === currentNode1.text.length) {
+            // 检查前一个字符是否是空格
+            var lastChar = currentNode1.text.charAt(currentNode1.text.length - 1);
+            if (lastChar === ' ') {
+                // 如果前一个输入是空格，且当前输入也是空格，则插入一个空格到 tag 节点外
+                Transforms.insertNodes(editor, [
+                    {
+                        text: ' '
+                    }
+                ]);
+                return true;
+            }
+        }
+        if ((currentNode1 === null || currentNode1 === void 0 ? void 0 : currentNode1.tag) && operation.text.trim().length > 0 && currentNode1.text.trim().length === 0) {
+            Editor.withoutNormalizing(editor, function() {
+                Transforms.removeNodes(editor, {
+                    at: operation.path
+                });
+                Transforms.insertNodes(editor, _object_spread_props(_object_spread({}, currentNode1), {
+                    tag: true,
+                    code: true,
+                    text: operation.text
+                }), {
+                    at: operation.path,
+                    select: true
+                });
+            });
+            return true;
+        }
+    }
+    if (operation.type === 'split_node') {
+        var node = Node.get(editor, operation.path);
+        if ((node === null || node === void 0 ? void 0 : node.tag) || (node === null || node === void 0 ? void 0 : node.code)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * 扩展编辑器以处理代码和标签节点的操作
+ *
+ * @param editor - 要扩展的Slate编辑器实例
+ * @returns 增强后的编辑器实例，能够处理代码和标签相关操作
+ *
+ * @description
+ * 该插件重写编辑器的 `apply` 和 `deleteBackward` 方法，添加对代码和标签节点的特殊处理逻辑。
+ */ export var withCodeTagPlugin = function(editor) {
+    var apply = editor.apply, deleteBackward = editor.deleteBackward;
+    editor.apply = function(operation) {
+        // 尝试处理代码和标签相关操作
+        if (handleCodeTagOperation(editor, operation, apply)) {
+            return;
+        }
+        // 否则执行原始操作
+        apply(operation);
+    };
+    editor.deleteBackward = function(unit) {
+        var selection = editor.selection;
+        if (selection && hasRange(editor, selection) && Range.isCollapsed(selection)) {
+            var curNode = Node.get(editor, selection.anchor.path);
+            // 检查前一个节点是否是 tag
+            try {
+                var _ref = _sliced_to_array(Editor.previous(editor, {
+                    at: selection.anchor.path
+                }) || [], 2), previousNode = _ref[0], previousPath = _ref[1];
+                var isBeforeTag = selection && selection.anchor.offset <= 1;
+                if ((previousNode === null || previousNode === void 0 ? void 0 : previousNode.tag) && previousPath && isBeforeTag) {
+                    var _curNode_text, _curNode_text1;
+                    // 如果当前节点不为空,且只有一个文本
+                    if (((_curNode_text = curNode.text) === null || _curNode_text === void 0 ? void 0 : _curNode_text.trim()) && curNode.text.trimEnd().length === 1 && selection.anchor.offset > 0) {
+                        Transforms.insertText(editor, '', {
+                            at: selection.anchor.path
+                        });
+                        Transforms.insertNodes(editor, {
+                            type: 'paragraph',
+                            children: [
+                                {
+                                    text: ' '
+                                }
+                            ]
+                        }, {
+                            at: selection.anchor.path,
+                            select: true
+                        });
+                        return;
+                    } else if (((_curNode_text1 = curNode.text) === null || _curNode_text1 === void 0 ? void 0 : _curNode_text1.trim()) && selection.anchor.offset > 0) {
+                        deleteBackward(unit);
+                        return;
+                    }
+                    // 如果前一个节点是 tag，直接删除整个 tag
+                    Editor.withoutNormalizing(editor, function() {
+                        var parent = Node.get(editor, Path.parent(previousPath));
+                        var index = previousPath[previousPath.length - 1];
+                        if (parent.children.length === 1) {
+                            // 如果是唯一的节点，转换为普通文本
+                            Transforms.setNodes(editor, {
+                                tag: false,
+                                code: false,
+                                text: ' ',
+                                triggerText: undefined
+                            }, {
+                                at: previousPath
+                            });
+                        } else if (index === 0) {
+                            // 如果是第一个节点，删除并合并下一个节点
+                            Transforms.removeNodes(editor, {
+                                at: previousPath
+                            });
+                        } else {
+                            // 如果是中间或最后节点，先合并再删除
+                            Transforms.removeNodes(editor, {
+                                at: previousPath
+                            });
+                        }
+                    });
+                    return;
+                }
+            } catch (error) {
+            // 如果获取前一个节点失败，继续执行原始删除操作
+            }
+            try {
+                var _node_text_trim, _node_text, _selection_anchor;
+                var node = Node.get(editor, selection.anchor.path);
+                if ((node === null || node === void 0 ? void 0 : node.tag) && (node === null || node === void 0 ? void 0 : (_node_text = node.text) === null || _node_text === void 0 ? void 0 : (_node_text_trim = _node_text.trim()) === null || _node_text_trim === void 0 ? void 0 : _node_text_trim.length) < 1 && (selection === null || selection === void 0 ? void 0 : (_selection_anchor = selection.anchor) === null || _selection_anchor === void 0 ? void 0 : _selection_anchor.offset) < 1) {
+                    var _node_text1;
+                    var text = node === null || node === void 0 ? void 0 : (_node_text1 = node.text) === null || _node_text1 === void 0 ? void 0 : _node_text1.replace(node.triggerText || '', '');
+                    Transforms.setNodes(editor, {
+                        tag: false,
+                        code: false
+                    }, {
+                        at: selection.anchor.path
+                    });
+                    Transforms.insertText(editor, text, {
+                        at: selection.anchor.path
+                    });
+                    return;
+                }
+            } catch (unused) {}
+        }
+        deleteBackward(unit);
+    };
+    return editor;
+};

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

@@ -0,0 +1,12 @@
+import { Editor } from 'slate';
+/**
+ * 扩展编辑器以识别行内节点类型
+ *
+ * @param editor - 要扩展的Slate编辑器实例
+ * @returns 增强后的编辑器实例，能够识别行内节点
+ *
+ * @description
+ * 该插件扩展编辑器的 `isInline` 方法，使其能够识别特定的行内元素类型。
+ * 行内节点包括：'break'、'inline-katex'
+ */
+export declare const withInlineNodes: (editor: Editor) => import("slate").BaseEditor & import("slate-react").ReactEditor & import("slate-history").HistoryEditor;

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

@@ -0,0 +1,17 @@
+import { inlineNode } from "./utils";
+/**
+ * 扩展编辑器以识别行内节点类型
+ *
+ * @param editor - 要扩展的Slate编辑器实例
+ * @returns 增强后的编辑器实例，能够识别行内节点
+ *
+ * @description
+ * 该插件扩展编辑器的 `isInline` 方法，使其能够识别特定的行内元素类型。
+ * 行内节点包括：'break'、'inline-katex'
+ */ export var withInlineNodes = function(editor) {
+    var isInline = editor.isInline;
+    editor.isInline = function(element) {
+        return inlineNode.has(element.type) || isInline(element);
+    };
+    return editor;
+};

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

@@ -0,0 +1,11 @@
+import { Editor } from 'slate';
+/**
+ * 扩展编辑器以处理链接卡片和媒体节点的操作
+ *
+ * @param editor - 要扩展的Slate编辑器实例
+ * @returns 增强后的编辑器实例，能够处理链接和媒体相关操作
+ *
+ * @description
+ * 该插件重写编辑器的 `apply` 方法，添加对链接卡片和媒体节点的特殊处理逻辑。
+ */
+export declare const withLinkAndMediaPlugin: (editor: Editor) => import("slate").BaseEditor & import("slate-react").ReactEditor & import("slate-history").HistoryEditor;

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

@@ -0,0 +1,70 @@
+import { Node, Path, Transforms } from "slate";
+/**
+ * 处理链接卡片和媒体相关节点的操作
+ *
+ * @param editor - Slate编辑器实例
+ * @param operation - 要处理的操作
+ * @returns 如果操作被处理则返回true，否则返回false
+ *
+ * @description
+ * 处理以下链接和媒体相关操作:
+ * - 拆分链接卡片或媒体节点 (split_node)
+ * - 删除链接卡片内的节点 (remove_node)
+ */ var handleLinkAndMediaOperation = function(editor, operation) {
+    var _operation_properties, _operation_properties1;
+    if (operation.type === 'split_node' && (((_operation_properties = operation.properties) === null || _operation_properties === void 0 ? void 0 : _operation_properties.type) === 'link-card' || ((_operation_properties1 = operation.properties) === null || _operation_properties1 === void 0 ? void 0 : _operation_properties1.type) === 'media')) {
+        var node = Node.get(editor, operation.path);
+        if ([
+            'link-card',
+            'media'
+        ].includes(node === null || node === void 0 ? void 0 : node.type)) {
+            Transforms.insertNodes(editor, [
+                {
+                    type: 'paragraph',
+                    children: [
+                        {
+                            text: '',
+                            p: 'true'
+                        }
+                    ]
+                }
+            ], {
+                at: Path.next([
+                    operation.path.at(0)
+                ]),
+                select: true
+            });
+        }
+        return true;
+    }
+    if (operation.type === 'remove_node') {
+        var parentNode = Node.get(editor, Path.parent(operation.path));
+        if ('link-card' === parentNode.type) {
+            Transforms.removeNodes(editor, {
+                at: Path.parent(operation.path)
+            });
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * 扩展编辑器以处理链接卡片和媒体节点的操作
+ *
+ * @param editor - 要扩展的Slate编辑器实例
+ * @returns 增强后的编辑器实例，能够处理链接和媒体相关操作
+ *
+ * @description
+ * 该插件重写编辑器的 `apply` 方法，添加对链接卡片和媒体节点的特殊处理逻辑。
+ */ export var withLinkAndMediaPlugin = function(editor) {
+    var apply = editor.apply;
+    editor.apply = function(operation) {
+        // 尝试处理链接和媒体相关操作
+        if (handleLinkAndMediaOperation(editor, operation)) {
+            return;
+        }
+        // 否则执行原始操作
+        apply(operation);
+    };
+    return editor;
+};

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

@@ -0,0 +1,23 @@
+import { Editor } from 'slate';
+import { BulletedListNode, NumberedListNode } from '../../el';
+/**
+ * 判断节点是否为列表类型
+ */
+export declare const isListType: (node: any) => node is BulletedListNode | NumberedListNode;
+/**
+ * 根据 order 属性返回列表类型
+ */
+export declare const getListType: (order?: boolean) => 'bulleted-list' | 'numbered-list';
+/**
+ * 扩展编辑器以处理列表节点的规范化
+ *
+ * @param editor - 要扩展的Slate编辑器实例
+ * @returns 增强后的编辑器实例，能够规范化列表结构
+ *
+ * @description
+ * 该插件重写编辑器的 `normalizeNode` 方法，确保列表结构符合规范：
+ * - `bulleted-list` 和 `numbered-list` 的直接子节点必须是 `list-item`
+ * - `list-item` 的第一个子节点应该是块级元素（如 `paragraph`）
+ * - 自动修复不符合规范的结构
+ */
+export declare const withListsPlugin: (editor: Editor) => import("slate").BaseEditor & import("slate-react").ReactEditor & import("slate-history").HistoryEditor;

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

@@ -0,0 +1,204 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    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, Transforms } from "slate";
+/**
+ * 判断节点是否为列表类型
+ */ export var isListType = function(node) {
+    return Element.isElement(node) && (node.type === 'bulleted-list' || node.type === 'numbered-list');
+};
+/**
+ * 根据 order 属性返回列表类型
+ */ export var getListType = function(order) {
+    return order ? 'numbered-list' : 'bulleted-list';
+};
+/**
+ * 扩展编辑器以处理列表节点的规范化
+ *
+ * @param editor - 要扩展的Slate编辑器实例
+ * @returns 增强后的编辑器实例，能够规范化列表结构
+ *
+ * @description
+ * 该插件重写编辑器的 `normalizeNode` 方法，确保列表结构符合规范：
+ * - `bulleted-list` 和 `numbered-list` 的直接子节点必须是 `list-item`
+ * - `list-item` 的第一个子节点应该是块级元素（如 `paragraph`）
+ * - 自动修复不符合规范的结构
+ */ export var withListsPlugin = function(editor) {
+    var normalizeNode = editor.normalizeNode;
+    editor.normalizeNode = function(entry) {
+        var _entry = _sliced_to_array(entry, 2), node = _entry[0], path = _entry[1];
+        // 规则 1: 列表节点的直接子节点必须是 list-item
+        if (isListType(node)) {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = Node.children(editor, path)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var _step_value = _sliced_to_array(_step.value, 2), child = _step_value[0], childPath = _step_value[1];
+                    if (Element.isElement(child) && child.type !== 'list-item') {
+                        // 将非 list-item 节点转换为 list-item
+                        Transforms.setNodes(editor, {
+                            type: 'list-item'
+                        }, {
+                            at: childPath
+                        });
+                        return;
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        }
+        // 规则 2: list-item 的子节点结构规范化
+        if (Element.isElement(node) && node.type === 'list-item') {
+            // 确保 list-item 至少有一个子节点
+            if (node.children.length === 0) {
+                Transforms.insertNodes(editor, {
+                    type: 'paragraph',
+                    children: [
+                        {
+                            text: ''
+                        }
+                    ]
+                }, {
+                    at: _to_consumable_array(path).concat([
+                        0
+                    ])
+                });
+                return;
+            }
+            // 确保第一个子节点是块级元素（paragraph 或其他块级元素）
+            var firstChild = node.children[0];
+            if (Element.isElement(firstChild) && !Editor.isBlock(editor, firstChild) && firstChild.type !== 'paragraph') {
+                // 如果不是块级元素，包裹为 paragraph
+                Transforms.wrapNodes(editor, {
+                    type: 'paragraph',
+                    children: []
+                }, {
+                    at: _to_consumable_array(path).concat([
+                        0
+                    ])
+                });
+                return;
+            }
+            // 确保 list-item 的子节点中，除了第一个块级元素外，其他都是列表类型
+            // 允许的结构: [paragraph, bulleted-list?, numbered-list?]
+            for(var i = 1; i < node.children.length; i++){
+                var child1 = node.children[i];
+                if (Element.isElement(child1)) {
+                    if (!isListType(child1)) {
+                        // 如果不是列表类型，且不是第一个块级元素，需要处理
+                        // 如果它是块级元素，应该移到前面或转换为列表
+                        if (Editor.isBlock(editor, child1)) {
+                            // 将块级元素包裹为新的 list-item，并创建新的列表
+                            var listType = getListType();
+                            Transforms.wrapNodes(editor, {
+                                type: 'list-item',
+                                checked: undefined,
+                                mentions: [],
+                                id: '',
+                                children: []
+                            }, {
+                                at: _to_consumable_array(path).concat([
+                                    i
+                                ])
+                            });
+                            Transforms.wrapNodes(editor, {
+                                type: listType,
+                                children: []
+                            }, {
+                                at: _to_consumable_array(path).concat([
+                                    i
+                                ])
+                            });
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        // 规则 3: 向后兼容 - 将旧的 'list' 类型转换为新类型
+        if (Element.isElement(node) && node.type === 'list') {
+            var listType1 = getListType(node.order);
+            Transforms.setNodes(editor, {
+                type: listType1
+            }, {
+                at: path
+            });
+            // 移除 order 属性（已由类型表示）
+            if (node.order !== undefined) {
+                Transforms.unsetNodes(editor, 'order', {
+                    at: path
+                });
+            }
+            return;
+        }
+        // 执行原始的规范化逻辑
+        normalizeNode(entry);
+    };
+    return editor;
+};

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

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