@ant-design/agentic-ui 2.30.23 → 2.30.24

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/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,7 @@
+import { Editor } from 'slate';
+/**
+ * 外部或合并后的 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 & import("slate-history").HistoryEditor;

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

@@ -0,0 +1,217 @@
+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 _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";
+var isValidChild = function isValidChild(child) {
+    return child !== undefined && child !== null && Node.isNode(child);
+};
+var createDefaultBlock = function createDefaultBlock() {
+    return {
+        type: 'paragraph',
+        children: [
+            {
+                text: ''
+            }
+        ]
+    };
+};
+var rebuildElement = function rebuildElement(node) {
+    var children = node.children.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
+    });
+};
+/**
+ * 外部或合并后的 value 可能在 `children` 中混入 `undefined` / `null`；
+ * Slate 的 `Node.string` 会对每个子节点调用 `Text.isText`，遇 `undefined` 即抛错。
+ * 在 normalize 最外层剔除非法子节点，避免编辑器与 toMarkdown 崩溃。
+ */ export var withSanitizeInvalidChildren = function withSanitizeInvalidChildren(editor) {
+    var normalizeNode = editor.normalizeNode;
+    editor.normalizeNode = function(entry) {
+        var _entry = _sliced_to_array(entry, 2), node = _entry[0], path = _entry[1];
+        if (Editor.isEditor(node) && path.length === 0) {
+            var hasInvalid = node.children.some(function(c) {
+                return !isValidChild(c);
+            });
+            if (hasInvalid) {
+                var clean = node.children.filter(isValidChild);
+                editor.children = clean.length === 0 ? [
+                    createDefaultBlock()
+                ] : clean;
+                normalizeNode(entry);
+                return;
+            }
+            if (node.children.length === 0) {
+                editor.children = [
+                    createDefaultBlock()
+                ];
+                normalizeNode(entry);
+                return;
+            }
+            normalizeNode(entry);
+            return;
+        }
+        if (Node.isNode(node)) {
+            var hasInvalid1 = node.children.some(function(c) {
+                return !isValidChild(c);
+            });
+            if (hasInvalid1) {
+                Editor.withoutNormalizing(editor, function() {
+                    var rebuilt = rebuildElement(node);
+                    Transforms.removeNodes(editor, {
+                        at: path,
+                        voids: true
+                    });
+                    Transforms.insertNodes(editor, rebuilt, {
+                        at: path,
+                        voids: true
+                    });
+                });
+                return;
+            }
+        }
+        normalizeNode(entry);
+    };
+    return editor;
+};

package/package.json

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