@ant-design/agentic-ui 2.30.23 → 2.30.25

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

@@ -5,5 +5,6 @@ export * from './withInlineNodes';
 export * from './withLinkAndMediaPlugin';
 export * from './withListsPlugin';
 export * from './withMarkdown';
+export * from './withSanitizeInvalidChildren';
 export * from './withSchemaPlugin';
 export * from './withVoidNodes';

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

@@ -5,5 +5,6 @@ export * from "./withInlineNodes";
 export * from "./withLinkAndMediaPlugin";
 export * from "./withListsPlugin";
 export * from "./withMarkdown";
+export * from "./withSanitizeInvalidChildren";
 export * from "./withSchemaPlugin";
 export * from "./withVoidNodes";

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

@@ -115,8 +115,9 @@ import { Editor, Element, Node, Transforms } from "slate";
         }
         // 规则 2: list-item 的子节点结构规范化
         if (Element.isElement(node) && node.type === 'list-item') {
+            var listItemChildren = Array.isArray(node.children) ? node.children : [];
             // 确保 list-item 至少有一个子节点
-            if (node.children.length === 0) {
+            if (listItemChildren.length === 0) {
                 Transforms.insertNodes(editor, {
                     type: 'paragraph',
                     children: [
@@ -132,7 +133,7 @@ import { Editor, Element, Node, Transforms } from "slate";
                 return;
             }
             // 确保第一个子节点是块级元素（paragraph 或其他块级元素）
-            var firstChild = node.children[0];
+            var firstChild = listItemChildren[0];
             if (Element.isElement(firstChild) && !Editor.isBlock(editor, firstChild) && firstChild.type !== 'paragraph') {
                 // 如果不是块级元素，包裹为 paragraph
                 Transforms.wrapNodes(editor, {
@@ -147,8 +148,8 @@ import { Editor, Element, Node, Transforms } from "slate";
             }
             // 确保 list-item 的子节点中，除了第一个块级元素外，其他都是列表类型
             // 允许的结构: [paragraph, bulleted-list?, numbered-list?]
-            for(var i = 1; i < node.children.length; i++){
-                var child1 = node.children[i];
+            for(var i = 1; i < listItemChildren.length; i++){
+                var child1 = listItemChildren[i];
                 if (Element.isElement(child1)) {
                     if (!isListType(child1)) {
                         if (Editor.isBlock(editor, child1)) {

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

@@ -4,6 +4,7 @@ import { withInlineNodes } from "./withInlineNodes";
 import { withLinkAndMediaPlugin } from "./withLinkAndMediaPlugin";
 import { withListsPlugin } from "./withListsPlugin";
 import { withSchemaPlugin } from "./withSchemaPlugin";
+import { withSanitizeInvalidChildren } from "./withSanitizeInvalidChildren";
 import { withVoidNodes } from "./withVoidNodes";
 /**
  * 为Slate编辑器添加Markdown支持的插件函数
@@ -22,5 +23,5 @@ import { withVoidNodes } from "./withVoidNodes";
  *
  * 插件按顺序应用，每个插件都会增强编辑器的特定功能。
  */ export var withMarkdown = function withMarkdown(editor) {
-    return withCodeTagPlugin(withSchemaPlugin(withLinkAndMediaPlugin(withCardPlugin(withListsPlugin(withVoidNodes(withInlineNodes(editor)))))));
+    return withSanitizeInvalidChildren(withCodeTagPlugin(withSchemaPlugin(withLinkAndMediaPlugin(withCardPlugin(withListsPlugin(withVoidNodes(withInlineNodes(editor))))))));
 };

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

@@ -0,0 +1,8 @@
+import { Editor } from 'slate';
+import { HistoryEditor } from 'slate-history';
+/**
+ * 外部或合并后的 value 可能在 `children` 中混入 `undefined` / `null`；
+ * Slate 的 `Node.string` 会对每个子节点调用 `Text.isText`，遇 `undefined` 即抛错。
+ * 在 normalize 最外层剔除非法子节点，避免编辑器与 toMarkdown 崩溃。
+ */
+export declare const withSanitizeInvalidChildren: (editor: Editor) => import("slate").BaseEditor & import("slate-react").ReactEditor & HistoryEditor;

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

@@ -0,0 +1,330 @@
+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 _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys, key, i;
+    if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
+        sourceKeys = Reflect.ownKeys(source);
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+        return target;
+    }
+    target = _object_without_properties_loose(source, excluded);
+    if (Object.getOwnPropertySymbols) {
+        sourceKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = 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 _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+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, Transforms } from "slate";
+import { HistoryEditor } from "slate-history";
+import { EditorUtils } from "../utils/editorUtils";
+var isValidChild = function isValidChild(child) {
+    return child !== undefined && child !== null && Node.isNode(child);
+};
+var getChildList = function getChildList(node) {
+    if (!('children' in node)) {
+        return [];
+    }
+    var children = node.children;
+    return Array.isArray(children) ? children : [];
+};
+var createDefaultBlock = function createDefaultBlock() {
+    return {
+        type: 'paragraph',
+        children: [
+            {
+                text: ''
+            }
+        ]
+    };
+};
+var rebuildElement = function rebuildElement(node) {
+    var children = getChildList(node).filter(isValidChild);
+    if (children.length === 0 && 'type' in node && node.type) {
+        children = [
+            {
+                text: ''
+            }
+        ];
+    }
+    var _drop = node.children, rest = _object_without_properties(node, [
+        "children"
+    ]);
+    return _object_spread_props(_object_spread({}, rest), {
+        children: children
+    });
+};
+var runWithoutHistory = function runWithoutHistory(editor, fn) {
+    if (HistoryEditor.isHistoryEditor(editor)) {
+        HistoryEditor.withoutSaving(editor, fn);
+    } else {
+        fn();
+    }
+};
+/**
+ * Slate 的 `Node.nodes` / `Editor.normalize` 在遍历时假定非文本节点必有数组型 `children`。
+ * 若仅有 `type` 而缺少 `children`，会在进入自定义 `normalizeNode` 之前就抛错，必须先修树。
+ */ var rebuildOrDefaultBlock = function rebuildOrDefaultBlock(raw) {
+    if (raw && (typeof raw === "undefined" ? "undefined" : _type_of(raw)) === 'object' && //@ts-ignore
+    !(Node === null || Node === void 0 ? void 0 : Node.isText(raw)) && typeof raw.type === 'string') {
+        return rebuildElement(raw);
+    }
+    return createDefaultBlock();
+};
+var repairBrokenChildArrays = function repairBrokenChildArrays(editor) {
+    if (!Array.isArray(editor.children)) {
+        /* eslint-disable no-param-reassign */ editor.children = [
+            createDefaultBlock()
+        ];
+        /* eslint-enable no-param-reassign */ return true;
+    }
+    if (editor.children.length === 0) {
+        EditorUtils.replaceEditorContent(editor, [
+            createDefaultBlock()
+        ]);
+        return true;
+    }
+    for(var i = 0; i < editor.children.length; i++){
+        var child = editor.children[i];
+        if (!isValidChild(child)) {
+            /* eslint-disable no-param-reassign */ editor.children[i] = rebuildOrDefaultBlock(child);
+            /* eslint-enable no-param-reassign */ return true;
+        }
+    }
+    var fixBranch = function fixBranch1(node) {
+        var _Node_isText;
+        if (!node || (typeof node === "undefined" ? "undefined" : _type_of(node)) !== 'object') {
+            return false;
+        }
+        //@ts-ignore
+        if (Node === null || Node === void 0 ? void 0 : (_Node_isText = Node.isText) === null || _Node_isText === void 0 ? void 0 : _Node_isText.call(Node, node)) {
+            return false;
+        }
+        var rawChildren = node.children;
+        if (!Array.isArray(rawChildren)) {
+            Object.assign(node, rebuildElement(node));
+            return true;
+        }
+        if (rawChildren === null || rawChildren === void 0 ? void 0 : rawChildren.some(function(c) {
+            return !isValidChild(c);
+        })) {
+            var fixedChildren = rawChildren.filter(isValidChild);
+            node.children = fixedChildren.length === 0 ? [
+                {
+                    text: ''
+                }
+            ] : fixedChildren;
+            return true;
+        }
+        for(var i = 0; i < rawChildren.length; i++){
+            if (fixBranch(rawChildren[i])) {
+                return true;
+            }
+        }
+        return false;
+    };
+    for(var i1 = 0; i1 < editor.children.length; i1++){
+        if (fixBranch(editor.children[i1])) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * 外部或合并后的 value 可能在 `children` 中混入 `undefined` / `null`；
+ * Slate 的 `Node.string` 会对每个子节点调用 `Text.isText`，遇 `undefined` 即抛错。
+ * 在 normalize 最外层剔除非法子节点，避免编辑器与 toMarkdown 崩溃。
+ */ export var withSanitizeInvalidChildren = function withSanitizeInvalidChildren(editor) {
+    var normalizeNode = editor.normalizeNode, normalize = editor.normalize;
+    editor.normalize = function(options) {
+        var guard = 0;
+        while(guard < 100 && repairBrokenChildArrays(editor)){
+            guard += 1;
+        }
+        return normalize.call(editor, options);
+    };
+    editor.normalizeNode = function(entry) {
+        var _Node_isText;
+        var _entry = _sliced_to_array(entry, 2), node = _entry[0], path = _entry[1];
+        // `Node.isNode` is true for text leaves, but they have no `children`; never call `.some` on them.
+        //@ts-ignore
+        if (Node === null || Node === void 0 ? void 0 : (_Node_isText = Node.isText) === null || _Node_isText === void 0 ? void 0 : _Node_isText.call(Node, node)) {
+            normalizeNode(entry);
+            return;
+        }
+        if (Editor.isEditor(node) && path.length === 0) {
+            var childList = getChildList(node);
+            var hasInvalid = childList.some(function(c) {
+                return !isValidChild(c);
+            });
+            if (hasInvalid || childList.length === 0) {
+                var nextNodes = childList.length === 0 ? [
+                    createDefaultBlock()
+                ] : childList.map(function(c) {
+                    return isValidChild(c) ? c : rebuildOrDefaultBlock(c);
+                });
+                EditorUtils.replaceEditorContent(editor, nextNodes);
+                normalizeNode(entry);
+                return;
+            }
+            normalizeNode(entry);
+            return;
+        }
+        //@ts-ignore
+        if (!Editor.isEditor(node) && !Node.isText(node)) {
+            var rawChildren = node.children;
+            if (!Array.isArray(rawChildren)) {
+                Object.assign(node, rebuildElement(node));
+                normalizeNode(entry);
+                return;
+            }
+        }
+        //@ts-ignore
+        if (Node.isElement(node)) {
+            var childList1 = getChildList(node);
+            var hasInvalid1 = childList1.some(function(c) {
+                return !isValidChild(c);
+            });
+            if (hasInvalid1) {
+                var applyRebuild = function applyRebuild() {
+                    Editor.withoutNormalizing(editor, function() {
+                        var rebuilt = rebuildElement(node);
+                        Transforms.removeNodes(editor, {
+                            at: path,
+                            voids: true
+                        });
+                        Transforms.insertNodes(editor, rebuilt, {
+                            at: path,
+                            voids: true
+                        });
+                    });
+                };
+                runWithoutHistory(editor, applyRebuild);
+                return;
+            }
+        }
+        normalizeNode(entry);
+    };
+    return editor;
+};

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

@@ -662,9 +662,7 @@ export declare class EditorStore {
         maxResults?: number;
     }): {
         path: Path;
-        range: import("slate").BaseRange; /**
-         * 更新结构不同的表格
-         */
+        range: import("slate").BaseRange;
         node: any;
         matchedText: string;
         offset: {

package/dist/MarkdownEditor/editor/store.js

@@ -435,6 +435,10 @@ export var EditorStoreContext = createContext(null);
             value: function setMDContent(md, plugins, options) {
                 var _ref, _ref1, _ref2, _ref3;
                 if (md === undefined) return;
+                if (!md) {
+                    this.clearContent();
+                    return;
+                }
                 if (this._shouldSkipSetContent(md)) return;
                 this.cancelSetMDContent();
                 var chunkSize = (_ref = options === null || options === void 0 ? void 0 : options.chunkSize) !== null && _ref !== void 0 ? _ref : 5000;

package/dist/MarkdownInputField/MarkdownInputField.js

@@ -140,7 +140,6 @@ import { useLocale } from "../I18n";
 import { BaseMarkdownEditor } from "../MarkdownEditor";
 import { BorderBeamAnimation } from "./BorderBeamAnimation";
 import { useFileUploadManager } from "./FileUploadManager";
-import { resolveSendDisabled } from "./SendButton";
 import { useMarkdownInputFieldActions } from "./hooks/useMarkdownInputFieldActions";
 import { useMarkdownInputFieldHandlers } from "./hooks/useMarkdownInputFieldHandlers";
 import { useMarkdownInputFieldLayout } from "./hooks/useMarkdownInputFieldLayout";
@@ -148,6 +147,7 @@ import { useMarkdownInputFieldRefs } from "./hooks/useMarkdownInputFieldRefs";
 import { useMarkdownInputFieldState } from "./hooks/useMarkdownInputFieldState";
 import { useMarkdownInputFieldStyles } from "./hooks/useMarkdownInputFieldStyles";
 import { QuickActions } from "./QuickActions";
+import { resolveSendDisabled } from "./SendButton";
 import { SkillModeBar } from "./SkillModeBar";
 import { useStyle } from "./style";
 import { Suggestion } from "./Suggestion";

package/dist/MarkdownInputField/hooks/useMarkdownInputFieldRefs.js

@@ -94,6 +94,9 @@ import { ReactEditor } from "slate-react";
             // ReactEditor.isFocused can throw if the editor is being torn down
             }
         }
+        if (props.value === undefined || props.value === '') {
+            return;
+        }
         (_markdownEditorRef_current1 = markdownEditorRef.current) === null || _markdownEditorRef_current1 === void 0 ? void 0 : (_markdownEditorRef_current_store = _markdownEditorRef_current1.store) === null || _markdownEditorRef_current_store === void 0 ? void 0 : _markdownEditorRef_current_store.setMDContent((_props_value = props.value) !== null && _props_value !== void 0 ? _props_value : '');
     }, [
         props.value

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ant-design/agentic-ui",
-  "version": "2.30.23",
+  "version": "2.30.25",
   "description": "面向智能体的 UI 组件库，提供多步推理可视化、工具调用展示、任务执行协同等 Agentic UI 能力",
   "repository": "git@github.com:ant-design/agentic-ui.git",
   "license": "MIT",