@ant-design/agentic-ui 2.29.7 → 2.29.9

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

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

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

@@ -0,0 +1,55 @@
+import { Node, Path, Transforms } from "slate";
+/**
+ * 处理schema相关节点的操作
+ *
+ * @param editor - Slate编辑器实例
+ * @param operation - 要处理的操作
+ * @returns 如果操作被处理则返回true，否则返回false
+ *
+ * @description
+ * 处理以下schema相关操作:
+ * - 拆分schema节点 (split_node)，在拆分点之后插入新的段落节点
+ */ var handleSchemaOperation = function(editor, operation) {
+    var _operation_properties;
+    if (operation.type === 'split_node' && ((_operation_properties = operation.properties) === null || _operation_properties === void 0 ? void 0 : _operation_properties.type) === 'schema') {
+        var node = Node.get(editor, operation.path);
+        if ((node === null || node === void 0 ? void 0 : node.type) === 'schema') {
+            Transforms.insertNodes(editor, [
+                {
+                    type: 'paragraph',
+                    children: [
+                        {
+                            text: '',
+                            p: 'true'
+                        }
+                    ]
+                }
+            ], {
+                at: Path.next(operation.path),
+                select: true
+            });
+        }
+        return true;
+    }
+    return false;
+};
+/**
+ * 扩展编辑器以处理schema节点的操作
+ *
+ * @param editor - 要扩展的Slate编辑器实例
+ * @returns 增强后的编辑器实例，能够处理schema相关操作
+ *
+ * @description
+ * 该插件重写编辑器的 `apply` 方法，添加对schema节点的特殊处理逻辑。
+ */ export var withSchemaPlugin = function(editor) {
+    var apply = editor.apply;
+    editor.apply = function(operation) {
+        // 尝试处理schema相关操作
+        if (handleSchemaOperation(editor, operation)) {
+            return;
+        }
+        // 否则执行原始操作
+        apply(operation);
+    };
+    return editor;
+};

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

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

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

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

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
                             ]
                         });
                     }
@@ -1067,7 +959,7 @@ export var EditorStoreContext = createContext(null);
    */ function _isValidNode(item) {
                 if (!item) return false;
                 if (item.type === 'p' && (!item.children || item.children.length === 0)) return false;
-                if (item.type === 'list' && (!item.children || item.children.length === 0)) return false;
+                if ((item.type === 'list' || item.type === 'bulleted-list' || item.type === 'numbered-list') && (!item.children || item.children.length === 0)) return false;
                 if (item.type === 'listItem' && (!item.children || item.children.length === 0)) return false;
                 if (item.type === 'code' && item.language === 'code' && (!item.otherProps || item.otherProps.length === 0)) return false;
                 if (item.type === 'image' && !item.src) return false;

package/dist/MarkdownEditor/editor/utils/docx/module.js

@@ -1,3 +1,31 @@
+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 _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;
+}
 /* eslint-disable @typescript-eslint/no-use-before-define */ import { message } from "antd";
 import { ELEMENT_TAGS } from "../../plugins/insertParsedHtmlNodes";
 export var TEXT_TAGS = {
@@ -119,24 +147,29 @@ export var makeDeserializer = function(jsx) {
                 return jsx('element', attrs, (attrs === null || attrs === void 0 ? void 0 : attrs.children) || children);
             }
             if (nodeName === 'H3' || nodeName === 'H2' || nodeName === 'H1') {
-                return jsx('element', {
+                var _ELEMENT_TAGS_nodeName1;
+                var attrs1 = (_ELEMENT_TAGS_nodeName1 = ELEMENT_TAGS[nodeName]) === null || _ELEMENT_TAGS_nodeName1 === void 0 ? void 0 : _ELEMENT_TAGS_nodeName1.call(ELEMENT_TAGS, el);
+                var align = attrs1 === null || attrs1 === void 0 ? void 0 : attrs1.align;
+                return jsx('element', _object_spread({
                     type: 'head',
                     className: nodeName,
-                    level: nodeName === null || nodeName === void 0 ? void 0 : nodeName.replace('H', '')
-                }, children);
+                    level: (attrs1 === null || attrs1 === void 0 ? void 0 : attrs1.level) || Number(nodeName === null || nodeName === void 0 ? void 0 : nodeName.replace('H', ''))
+                }, align ? {
+                    align: align
+                } : {}), children);
             }
-            var attrs1 = (_ELEMENT_TAGS_nodeName = ELEMENT_TAGS[nodeName]) === null || _ELEMENT_TAGS_nodeName === void 0 ? void 0 : _ELEMENT_TAGS_nodeName.call(ELEMENT_TAGS, el);
-            return jsx('element', attrs1, children);
+            var attrs2 = (_ELEMENT_TAGS_nodeName = ELEMENT_TAGS[nodeName]) === null || _ELEMENT_TAGS_nodeName === void 0 ? void 0 : _ELEMENT_TAGS_nodeName.call(ELEMENT_TAGS, el);
+            return jsx('element', attrs2, children);
         }
         if (TEXT_TAGS[nodeName]) {
             var _TEXT_TAGS_nodeName;
-            var attrs2 = (_TEXT_TAGS_nodeName = TEXT_TAGS[nodeName]) === null || _TEXT_TAGS_nodeName === void 0 ? void 0 : _TEXT_TAGS_nodeName.call(TEXT_TAGS);
+            var attrs3 = (_TEXT_TAGS_nodeName = TEXT_TAGS[nodeName]) === null || _TEXT_TAGS_nodeName === void 0 ? void 0 : _TEXT_TAGS_nodeName.call(TEXT_TAGS);
             try {
                 return children.filter(Boolean).map(function(child) {
                     if (typeof child === 'string') {
-                        return jsx('text', attrs2, child);
+                        return jsx('text', attrs3, child);
                     }
-                    return jsx('element', ELEMENT_TAGS.P(), child);
+                    return jsx('element', ELEMENT_TAGS.P(el), child);
                 });
             } catch (error) {
                 console.error(error);

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

@@ -0,0 +1,97 @@
+import { Editor, Path } from 'slate';
+/**
+ * 获取当前编辑器中的最低层级元素节点
+ */
+export declare function getCurrentNodes(editor: Editor): Generator<import("slate").NodeEntry<any>, void, undefined>;
+/**
+ * 插入表格
+ *
+ * 在当前位置插入一个3x3的表格（包含表头行）。
+ * 根据当前节点类型（段落、标题或列单元格）
+ * 决定在何处插入表格及如何处理现有内容。
+ *
+ * @param editor Slate 编辑器实例
+ * @param node 可选的节点，如果不提供则从编辑器获取
+ */
+export declare function insertTable(editor: Editor, node?: [any, Path]): void;
+/**
+ * 插入代码块
+ *
+ * 在当前位置插入代码块，并根据传入的类型设置语言和渲染模式。
+ * 支持在列单元格内或普通段落/标题后插入代码块。
+ *
+ * @param editor Slate 编辑器实例
+ * @param type 可选的代码块类型，'mermaid'表示流程图，'html'表示HTML渲染
+ * @param node 可选的节点，如果不提供则从编辑器获取
+ */
+export declare function insertCodeBlock(editor: Editor, type?: 'mermaid' | 'html', node?: [any, Path]): void;
+/**
+ * 插入或移除引用块
+ *
+ * 如果当前节点已在引用块中，则移除引用块；
+ * 否则，将当前节点转换为引用块。
+ * 如果当前节点是标题，先将其转换为普通段落。
+ *
+ * @param editor Slate 编辑器实例
+ * @param node 可选的节点，如果不提供则从编辑器获取
+ */
+export declare function toggleQuote(editor: Editor, node?: [any, Path]): void;
+/**
+ * 插入水平分割线
+ *
+ * 在当前位置插入水平分割线，并将光标定位到分割线后的位置。
+ * 如果分割线后没有内容，则自动插入一个空段落并将光标定位到该段落。
+ *
+ * @param editor Slate 编辑器实例
+ * @param node 可选的节点，如果不提供则从编辑器获取
+ */
+export declare function insertHorizontalLine(editor: Editor, node?: [any, Path]): void;
+/**
+ * 将标题转换为普通段落
+ *
+ * 如果当前节点是标题类型，将其转换为普通段落
+ *
+ * @param editor Slate 编辑器实例
+ */
+declare function convertToParagraph(editor: Editor): void;
+/**
+ * 设置标题级别
+ *
+ * 将当前段落或标题节点转换为指定级别的标题。
+ * 如果级别为4，则转换为普通段落。
+ *
+ * @param editor Slate 编辑器实例
+ * @param level 标题级别（1-3）或4（表示普通段落）
+ */
+export declare function setHeading(editor: Editor, level: number): void;
+export { convertToParagraph };
+/**
+ * 创建或转换列表
+ *
+ * 将当前段落或标题转换为指定类型的列表。
+ * 如果已经是列表项，则根据情况切换类型或解包。
+ *
+ * @param editor Slate 编辑器实例
+ * @param mode 列表类型 'ordered'(有序列表), 'unordered'(无序列表), 'task'(任务列表)
+ */
+export declare function createList(editor: Editor, mode: 'ordered' | 'unordered' | 'task'): void;
+/**
+ * 增加标题级别（使标题变小）
+ *
+ * 将段落转换为4级标题，
+ * 或将标题级别从1级改为普通段落，
+ * 或将其他级别标题升级一级（数字变小）
+ *
+ * @param editor Slate 编辑器实例
+ */
+export declare function increaseHeadingLevel(editor: Editor): void;
+/**
+ * 降低标题级别（使标题变大）
+ *
+ * 将段落转换为1级标题，
+ * 或将4级标题改为普通段落，
+ * 或将其他级别标题降级一级（数字变大）
+ *
+ * @param editor Slate 编辑器实例
+ */
+export declare function decreaseHeadingLevel(editor: Editor): void;