@ant-design/agentic-ui 2.30.22 → 2.30.24

package/dist/MarkdownInputField/SendActions/index.js

@@ -58,7 +58,7 @@ import React, { useContext, useMemo } from "react";
 import { ActionIconBox } from "../../Components/ActionIconBox";
 import { I18nContext } from "../../I18n";
 import { AttachmentButton } from "../AttachmentButton";
-import { SendButton } from "../SendButton";
+import { SendButton, resolveSendDisabled } from "../SendButton";
 import { VoiceInputButton } from "../VoiceInput";
 import { MARKDOWN_INPUT_FIELD_TEST_IDS } from "../testIds";
 /**
@@ -68,6 +68,7 @@ import { MARKDOWN_INPUT_FIELD_TEST_IDS } from "../testIds";
  */ export var SendActions = function SendActions(param) {
     var attachment = param.attachment, voiceRecognizer = param.voiceRecognizer, value = param.value, disabled = param.disabled, typing = param.typing, isLoading = param.isLoading, _param_fileUploadDone = param.fileUploadDone, fileUploadDone = _param_fileUploadDone === void 0 ? true : _param_fileUploadDone, _param_fileUploadStatus = param.fileUploadStatus, fileUploadStatus = _param_fileUploadStatus === void 0 ? fileUploadDone ? 'done' : 'uploading' : _param_fileUploadStatus, fileUploadSummary = param.fileUploadSummary, _param_recording = param.recording, recording = _param_recording === void 0 ? false : _param_recording, _param_collapseSendActions = param.collapseSendActions, collapseSendActions = _param_collapseSendActions === void 0 ? false : _param_collapseSendActions, _param_allowEmptySubmit = param.allowEmptySubmit, allowEmptySubmit = _param_allowEmptySubmit === void 0 ? false : _param_allowEmptySubmit, uploadImage = param.uploadImage, onStartRecording = param.onStartRecording, onStopRecording = param.onStopRecording, onSend = param.onSend, onStop = param.onStop, actionsRender = param.actionsRender, _param_prefixCls = param.prefixCls, prefixCls = _param_prefixCls === void 0 ? 'ant-agentic-md-input-field' : _param_prefixCls, _param_hashId = param.hashId, hashId = _param_hashId === void 0 ? '' : _param_hashId, _param_hasTools = param.hasTools, hasTools = _param_hasTools === void 0 ? false : _param_hasTools, onResize = param.onResize, sendButtonProps = param.sendButtonProps, triggerSendKey = param.triggerSendKey;
     var fileMap = attachment === null || attachment === void 0 ? void 0 : attachment.fileMap;
+    var sendDisabled = resolveSendDisabled(sendButtonProps, fileUploadStatus);
     var defaultActionsLen = [
         (attachment === null || attachment === void 0 ? void 0 : attachment.enable) ? '()' : null,
         voiceRecognizer ? '()' : null,
@@ -104,11 +105,10 @@ import { MARKDOWN_INPUT_FIELD_TEST_IDS } from "../testIds";
                     return Promise.resolve();
                 }
             }) : null,
-            /*#__PURE__*/ React.createElement(SendButton, _object_spread({
+            /*#__PURE__*/ React.createElement(SendButton, _object_spread_props(_object_spread({
                 key: "send-button",
                 typing: !!typing || !!isLoading,
                 isSendable: allowEmptySubmit || !!(value === null || value === void 0 ? void 0 : value.trim()) || fileMap && fileMap.size > 0 || recording,
-                disabled: disabled,
                 onClick: function onClick() {
                     if (typing || isLoading) {
                         onStop === null || onStop === void 0 ? void 0 : onStop();
@@ -117,11 +117,14 @@ import { MARKDOWN_INPUT_FIELD_TEST_IDS } from "../testIds";
                     onSend === null || onSend === void 0 ? void 0 : onSend();
                 },
                 triggerSendKey: triggerSendKey
-            }, sendButtonProps))
+            }, sendButtonProps), {
+                disabled: disabled || sendDisabled
+            }))
         ].filter(Boolean);
     }, [
         attachment,
         fileUploadDone,
+        sendDisabled,
         value,
         collapseSendActions,
         isLoading,

package/dist/MarkdownInputField/SendButton/index.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import type { FileUploadManagerReturn } from '../FileUploadManager';
 /**
  * 按钮颜色配置
  */
@@ -18,7 +19,12 @@ export type SendButtonColors = {
 export type SendButtonCustomizationProps = {
     compact?: boolean;
     colors?: SendButtonColors;
+    disabled?: boolean;
 };
+/**
+ * 解析发送按钮的最终禁用状态：用户显式传入优先，否则按上传状态判断
+ */
+export declare function resolveSendDisabled(sendButtonProps: SendButtonCustomizationProps | undefined, fileUploadStatus: FileUploadManagerReturn['fileUploadStatus'] | undefined): boolean;
 /**
  * Props for the SendButton component.
  */

package/dist/MarkdownInputField/SendButton/index.js

@@ -70,6 +70,12 @@ import { ErrorBoundary } from "react-error-boundary";
 import { StopIcon } from "../../AgentRunBar/icons";
 import { I18nContext } from "../../I18n";
 import { useStyle } from "./style";
+/**
+ * 解析发送按钮的最终禁用状态：用户显式传入优先，否则按上传状态判断
+ */ export function resolveSendDisabled(sendButtonProps, fileUploadStatus) {
+    var _ref;
+    return (_ref = sendButtonProps === null || sendButtonProps === void 0 ? void 0 : sendButtonProps.disabled) !== null && _ref !== void 0 ? _ref : fileUploadStatus === 'uploading';
+}
 var DEFAULT_SEND_BUTTON_COLORS = {
     icon: '#00183D',
     iconHover: '#fff',

package/dist/MarkdownInputField/hooks/useMarkdownInputFieldHandlers.d.ts

@@ -4,6 +4,7 @@ import type { AttachmentFile } from '../AttachmentButton/types';
 import type { MarkdownInputFieldProps } from '../types/MarkdownInputFieldProps';
 interface UseMarkdownInputFieldHandlersParams {
     props: Pick<MarkdownInputFieldProps, 'disabled' | 'typing' | 'onChange' | 'onSend' | 'allowEmptySubmit' | 'markdownProps' | 'attachment' | 'triggerSendKey'>;
+    sendDisabled?: boolean;
     markdownEditorRef: React.MutableRefObject<MarkdownEditorInstance | undefined>;
     inputRef: React.RefObject<HTMLDivElement>;
     isSendingRef: React.MutableRefObject<boolean>;
@@ -22,7 +23,7 @@ interface UseMarkdownInputFieldHandlersParams {
  * 事件处理 Hook
  * 管理组件中的所有事件处理函数
  */
-export declare const useMarkdownInputFieldHandlers: ({ props, markdownEditorRef, inputRef, isSendingRef, isLoading, setIsLoading, value, setValue, fileMap, setFileMap, recording, stopRecording, isEnlarged, setIsEnlarged, }: UseMarkdownInputFieldHandlersParams) => {
+export declare const useMarkdownInputFieldHandlers: ({ props, sendDisabled, markdownEditorRef, inputRef, isSendingRef, isLoading, setIsLoading, value, setValue, fileMap, setFileMap, recording, stopRecording, isEnlarged, setIsEnlarged, }: UseMarkdownInputFieldHandlersParams) => {
     handleEnlargeClick: () => void;
     sendMessage: () => Promise<void>;
     handlePaste: (e: React.ClipboardEvent<HTMLDivElement>) => Promise<void>;

package/dist/MarkdownInputField/hooks/useMarkdownInputFieldHandlers.js

@@ -189,7 +189,7 @@ import { getFileListFromDataTransferItems } from "../FilePaste";
  * 事件处理 Hook
  * 管理组件中的所有事件处理函数
  */ export var useMarkdownInputFieldHandlers = function useMarkdownInputFieldHandlers(param) {
-    var props = param.props, markdownEditorRef = param.markdownEditorRef, inputRef = param.inputRef, isSendingRef = param.isSendingRef, isLoading = param.isLoading, setIsLoading = param.setIsLoading, value = param.value, setValue = param.setValue, fileMap = param.fileMap, setFileMap = param.setFileMap, recording = param.recording, stopRecording = param.stopRecording, isEnlarged = param.isEnlarged, setIsEnlarged = param.setIsEnlarged;
+    var props = param.props, sendDisabled = param.sendDisabled, markdownEditorRef = param.markdownEditorRef, inputRef = param.inputRef, isSendingRef = param.isSendingRef, isLoading = param.isLoading, setIsLoading = param.setIsLoading, value = param.value, setValue = param.setValue, fileMap = param.fileMap, setFileMap = param.setFileMap, recording = param.recording, stopRecording = param.stopRecording, isEnlarged = param.isEnlarged, setIsEnlarged = param.setIsEnlarged;
     /**
    * 处理放大缩小按钮点击
    * @description 切换编辑器的放大/缩小状态
@@ -206,6 +206,7 @@ import { getFileListFromDataTransferItems } from "../FilePaste";
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
+                        // 这个 disable 是整体 input 的禁用
                         if (props.disabled) return [
                             2
                         ];
@@ -220,6 +221,10 @@ import { getFileListFromDataTransferItems } from "../FilePaste";
                         if (isSendingRef.current) return [
                             2
                         ];
+                        // 这个是发送按钮的单独禁用
+                        if (sendDisabled) return [
+                            2
+                        ];
                         if (!recording) return [
                             3,
                             2

package/dist/MarkdownRenderer/AnimationText.d.ts

@@ -14,10 +14,6 @@ export interface AnimationTextProps {
     children: React.ReactNode;
     animationConfig?: AnimationConfig;
 }
-/**
- * 流式文字淡入动画组件。
- *
- * 同一段流式前缀追加（或尾部截断修正）只触发一次入场动画；非前缀替换时重播。
- */
+/** 流式文字淡入，前缀追加只触发一次入场，非前缀替换时重播 */
 declare const AnimationText: React.NamedExoticComponent<AnimationTextProps>;
 export default AnimationText;

package/dist/MarkdownRenderer/AnimationText.js

@@ -45,9 +45,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 React, { useEffect, useMemo, useRef, useState } from "react";
-/**
- * 提取 React children 的纯文本
- */ var extractText = function extractText1(children) {
+var extractText = function extractText1(children) {
     var _children_props;
     if (typeof children === 'string') return children;
     if (typeof children === 'number') return String(children);
@@ -60,11 +58,7 @@ import React, { useEffect, useMemo, useRef, useState } from "react";
 /** 流式同一段内：前后文案仅「前缀关系」变化（增长或尾部截断修正） */ var isStreamingCompatible = function isStreamingCompatible(prev, next) {
     return prev.startsWith(next) || next.startsWith(prev);
 };
-/**
- * 流式文字淡入动画组件。
- *
- * 同一段流式前缀追加（或尾部截断修正）只触发一次入场动画；非前缀替换时重播。
- */ var AnimationText = /*#__PURE__*/ React.memo(function(param) {
+/** 流式文字淡入，前缀追加只触发一次入场，非前缀替换时重播 */ var AnimationText = /*#__PURE__*/ React.memo(function(param) {
     var children = param.children, animationConfig = param.animationConfig;
     var _ref = animationConfig || {}, _ref_fadeDuration = _ref.fadeDuration, fadeDuration = _ref_fadeDuration === void 0 ? 250 : _ref_fadeDuration, _ref_easing = _ref.easing, easing = _ref_easing === void 0 ? 'ease-out' : _ref_easing;
     var _useState = _sliced_to_array(useState(false), 2), animComplete = _useState[0], setAnimComplete = _useState[1];

package/dist/MarkdownRenderer/CharacterQueue.d.ts

@@ -23,9 +23,7 @@ export declare class CharacterQueue {
     complete(): void;
     /** 释放资源 */
     dispose(): void;
-    /** 当前已展示的长度 */
     getDisplayedLength(): number;
-    /** 完整内容 */
     getFullContent(): string;
     private ensureTicking;
     private tick;

package/dist/MarkdownRenderer/CharacterQueue.js

@@ -126,13 +126,13 @@ var DEFAULT_BACKGROUND_BATCH_MULTIPLIER = 10;
             }
         },
         {
-            /** 当前已展示的长度 */ key: "getDisplayedLength",
+            key: "getDisplayedLength",
             value: function getDisplayedLength() {
                 return this.displayedLength;
             }
         },
         {
-            /** 完整内容 */ key: "getFullContent",
+            key: "getFullContent",
             value: function getFullContent() {
                 return this.fullContent;
             }

package/dist/MarkdownRenderer/MarkdownRenderer.d.ts

@@ -1,13 +1,5 @@
 import React from 'react';
 import type { MarkdownRendererProps, MarkdownRendererRef } from './types';
-/**
- * MarkdownRenderer —— 流式/只读场景下的轻量 Markdown 渲染器。
- *
- * 核心优势：
- * - 不创建 Slate 实例，无编辑态开销
- * - 字符队列驱动流式逐字输出动画
- * - Markdown → hast → React 元素树（hast-util-to-jsx-runtime）
- * - 特殊块（code / mermaid / chart / katex）通过组件映射拦截渲染
- */
+/** 轻量流式 Markdown 渲染器——无 Slate 实例，Markdown → hast → React */
 declare const InternalMarkdownRenderer: React.ForwardRefExoticComponent<MarkdownRendererProps & React.RefAttributes<MarkdownRendererRef>>;
 export default InternalMarkdownRenderer;

package/dist/MarkdownRenderer/MarkdownRenderer.js

@@ -240,15 +240,7 @@ var SCHEMA_LANGUAGES = new Set([
         editorCodeProps: editorCodeProps
     }));
 };
-/**
- * MarkdownRenderer —— 流式/只读场景下的轻量 Markdown 渲染器。
- *
- * 核心优势：
- * - 不创建 Slate 实例，无编辑态开销
- * - 字符队列驱动流式逐字输出动画
- * - Markdown → hast → React 元素树（hast-util-to-jsx-runtime）
- * - 特殊块（code / mermaid / chart / katex）通过组件映射拦截渲染
- */ var InternalMarkdownRenderer = /*#__PURE__*/ forwardRef(function(props, ref) {
+/** 轻量流式 Markdown 渲染器——无 Slate 实例，Markdown → hast → React */ var InternalMarkdownRenderer = /*#__PURE__*/ forwardRef(function(props, ref) {
     var content = props.content, _props_streaming = props.streaming, streaming = _props_streaming === void 0 ? false : _props_streaming, isFinished = props.isFinished, queueOptions = props.queueOptions, plugins = props.plugins, remarkPlugins = props.remarkPlugins, htmlConfig = props.htmlConfig, className = props.className, style = props.style, customPrefixCls = props.prefixCls, linkConfig = props.linkConfig, streamingParagraphAnimation = props.streamingParagraphAnimation, apaasify = props.apaasify, eleRender = props.eleRender, fileMapConfig = props.fileMapConfig, fncProps = props.fncProps, editorCodeProps = props.codeProps;
     var getPrefixCls = useContext(ConfigProvider.ConfigContext).getPrefixCls;
     // 复用 MarkdownEditor 的 CSS 前缀和样式，保持渲染一致性

package/dist/MarkdownRenderer/StreamingCursor.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+/** 流式闪烁光标，由 MarkdownBlockPiece 控制挂载/卸载 */
+declare const StreamingCursor: React.FC;
+export { StreamingCursor };

package/dist/MarkdownRenderer/StreamingCursor.js

@@ -0,0 +1,20 @@
+import React from "react";
+/** 流式闪烁光标，由 MarkdownBlockPiece 控制挂载/卸载 */ var StreamingCursor = function StreamingCursor() {
+    return /*#__PURE__*/ React.createElement("span", {
+        "data-streaming-cursor": "",
+        "data-testid": "streaming-cursor",
+        "aria-hidden": "true",
+        style: {
+            display: 'inline-block',
+            width: 2,
+            height: '1.1em',
+            marginLeft: 2,
+            verticalAlign: 'text-bottom',
+            backgroundColor: 'currentColor',
+            borderRadius: 1,
+            animation: 'markdownStreamingCursorFadeIn 0.2s ease-out forwards, markdownStreamingCursorBlink 0.8s ease-in-out 0.2s infinite'
+        }
+    });
+};
+StreamingCursor.displayName = 'StreamingCursor';
+export { StreamingCursor };

package/dist/MarkdownRenderer/markdownReactShared.d.ts

@@ -4,12 +4,7 @@ import { type MarkdownRemarkPlugin, type MarkdownToHtmlConfig } from '../Markdow
 import type { MarkdownEditorProps } from '../MarkdownEditor/types';
 import type { MarkdownRendererEleProps, RendererBlockProps } from './types';
 declare const createHastProcessor: (extraRemarkPlugins?: MarkdownRemarkPlugin[], config?: MarkdownToHtmlConfig) => Processor;
-/**
- * 构建与 MarkdownEditor Readonly 组件对齐的 hast→React 组件映射。
- *
- * MarkdownEditor 的 Slate 元素使用 data-be 属性和 prefixCls 类名，
- * 这里为原生 HTML 标签添加相同的属性，使共用的 CSS 能正确命中。
- */
+/** hast → React 组件映射，与 MarkdownEditor Readonly 的 data-be / prefixCls 对齐 */
 declare const buildEditorAlignedComponents: (prefixCls: string, userComponents: Record<string, React.ComponentType<RendererBlockProps>>, streaming?: boolean, linkConfig?: {
     openInNewTab?: boolean | undefined;
     onClick?: ((url?: string) => boolean | void) | undefined;
@@ -52,52 +47,27 @@ declare const buildEditorAlignedComponents: (prefixCls: string, userComponents:
     think: (props: any) => React.FunctionComponentElement<import("../ToolUseBarThink").ToolUseBarThinkProps>;
     answer: (props: any) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
 };
-/**
- * 在 hast 上标记「最后一个 p」，用于流式时仅该段落播放入场（单块长文时避免全页 p 一起闪）
- */
-declare const markLastParagraphStreamingTail: (hast: any) => void;
-/**
- * 将单个 markdown 片段转为 React 元素（内部函数）
- */
-declare const renderMarkdownBlock: (blockContent: string, processor: Processor, components: Record<string, any>, blockOpts?: {
-    markStreamingTailParagraph?: boolean;
-}) => React.ReactNode;
-/**
- * 将 markdown 按块（双换行）拆分，尊重代码围栏边界。
- * 返回的每个块是一个独立的 markdown 片段，可单独解析。
- */
+/** markdown 片段 → React 元素 */
+declare const renderMarkdownBlock: (blockContent: string, processor: Processor, components: Record<string, any>) => React.ReactNode;
+/** 按双换行拆块，尊重代码围栏边界 */
 declare const splitMarkdownBlocks: (content: string) => string[];
 export interface UseMarkdownToReactOptions {
     remarkPlugins?: MarkdownRemarkPlugin[];
     htmlConfig?: MarkdownToHtmlConfig;
     components?: Record<string, React.ComponentType<RendererBlockProps>>;
-    /** MarkdownEditor 的 CSS 前缀，用于生成对齐的 className */
     prefixCls?: string;
-    /** 链接配置：onClick 拦截、openInNewTab 控制 */
     linkConfig?: {
         openInNewTab?: boolean;
         onClick?: (url?: string) => boolean | void;
     };
-    /** 脚注：与只读 Slate 路径 FncLeaf / fncProps 对齐 */
     fncProps?: MarkdownEditorProps['fncProps'];
-    /** 是否处于流式状态，用于最后一个块的打字动画 */
     streaming?: boolean;
-    /**
-     * 流式时是否对「生长中的末段」启用段落淡入（AnimationText）。
-     * 默认 false：重解析时频繁触发动画易导致整页闪动；需要时再显式传入 true。
-     */
+    /** 默认开启；传 false 关闭末段段落动画 */
     streamingParagraphAnimation?: boolean;
-    /**
-     * 单调增长的原始流字符串，仅用于判断是否应保留分块缓存。
-     * 与 `content`（常为 useStreaming 输出的可解析串）分离，避免占位符与正文切换时误判为非前缀修订。
-     */
+    /** 原始流字符串，与 useStreaming 输出分离避免缓存误判 */
     contentRevisionSource?: string;
-    /**
-     * 自定义元素渲染拦截函数（markdown 渲染模式）。
-     * 允许在默认渲染结果基础上包装、替换任意元素。
-     * 返回 undefined 时回退到默认渲染。
-     */
+    /** 返回 undefined 回退默认渲染 */
     eleRender?: (props: MarkdownRendererEleProps, defaultDom: React.ReactNode) => React.ReactNode;
 }
-export { buildEditorAlignedComponents, createHastProcessor, markLastParagraphStreamingTail, renderMarkdownBlock, splitMarkdownBlocks, };
+export { buildEditorAlignedComponents, createHastProcessor, renderMarkdownBlock, splitMarkdownBlocks, };
 export type { MarkdownRendererEleProps };

package/dist/MarkdownRenderer/markdownReactShared.js

@@ -392,9 +392,7 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
     }
     return undefined;
 };
-/**
- * 提取 React children 的文本内容
- */ var extractChildrenText = function extractChildrenText1(children) {
+var extractChildrenText = function extractChildrenText1(children) {
     var _children_props;
     if (typeof children === 'string') return children;
     if (typeof children === 'number') return String(children);
@@ -404,13 +402,7 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
     }
     return '';
 };
-/**
- * <think> 标签渲染组件——使用 ToolUseBarThink 替代原生 DOM。
- * 在 MarkdownEditor 中，<think> 被预处理为 ```think 代码块，
- * 然后由 ThinkBlock 组件（依赖 Slate 上下文）渲染为 ToolUseBarThink。
- * 在 MarkdownRenderer 中，<think> 通过 rehypeRaw 保留为 hast 元素，
- * 这里直接渲染为 ToolUseBarThink，无需 Slate 上下文。
- */ var ThinkBlockRendererComponent = function ThinkBlockRendererComponent(props) {
+/** <think> 标签 → ToolUseBarThink（MarkdownRenderer 无 Slate 上下文，直接渲染） */ var ThinkBlockRendererComponent = function ThinkBlockRendererComponent(props) {
     var children = props.children;
     var content = extractChildrenText(children);
     var isLoading = content.endsWith('...');
@@ -428,21 +420,16 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
         status: isLoading ? 'loading' : 'success'
     });
 };
-/**
- * 构建与 MarkdownEditor Readonly 组件对齐的 hast→React 组件映射。
- *
- * MarkdownEditor 的 Slate 元素使用 data-be 属性和 prefixCls 类名，
- * 这里为原生 HTML 标签添加相同的属性，使共用的 CSS 能正确命中。
- */ var buildEditorAlignedComponents = function buildEditorAlignedComponents(prefixCls, userComponents, streaming, linkConfig, fncProps, streamingParagraphAnimation, eleRender) {
+/** hast → React 组件映射，与 MarkdownEditor Readonly 的 data-be / prefixCls 对齐 */ var buildEditorAlignedComponents = function buildEditorAlignedComponents(prefixCls, userComponents, streaming, linkConfig, fncProps, streamingParagraphAnimation, eleRender) {
     var listCls = "".concat(prefixCls, "-list");
     var tableCls = "".concat(prefixCls, "-content-table");
     var contentCls = prefixCls; // e.g. ant-agentic-md-editor-content
-    /** 仅当 streaming、末块动画上下文允许且显式开启段落动画时包 AnimationText */ var StreamAnimWrap = function StreamAnimWrap(param) {
+    /** 仅当 streaming、末块动画上下文允许且未显式关闭段落动画时包 AnimationText */ var StreamAnimWrap = function StreamAnimWrap(param) {
         var children = param.children;
         var _ref;
         var ctx = useContext(StreamingAnimationContext);
         var animateBlock = (_ref = ctx === null || ctx === void 0 ? void 0 : ctx.animateBlock) !== null && _ref !== void 0 ? _ref : true;
-        var allow = !!streaming && animateBlock && !!streamingParagraphAnimation;
+        var allow = !!streaming && animateBlock && streamingParagraphAnimation !== false;
         if (!allow) return children;
         return jsx(AnimationText, {
             children: children
@@ -888,7 +875,7 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
             var defaultDom = jsx('mark', _object_spread_props(_object_spread({}, rest), {
                 'data-testid': 'markdown-mark',
                 style: {
-                    background: '#f59e0b',
+                    background: 'var(--ant-color-warning-bg, #f59e0b)',
                     padding: '0.1em 0.2em',
                     borderRadius: 2
                 },
@@ -1204,31 +1191,11 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
         }
     }, userComponents);
 };
-/**
- * 在 hast 上标记「最后一个 p」，用于流式时仅该段落播放入场（单块长文时避免全页 p 一起闪）
- */ var markLastParagraphStreamingTail = function markLastParagraphStreamingTail(hast) {
-    var paragraphs = [];
-    visit(hast, 'element', function(node) {
-        if (node.tagName === 'p') {
-            paragraphs.push(node);
-        }
-    });
-    var last = paragraphs[paragraphs.length - 1];
-    if (last) {
-        last.properties = last.properties || {};
-        last.properties.dataStreamingTail = true;
-    }
-};
-/**
- * 将单个 markdown 片段转为 React 元素（内部函数）
- */ var renderMarkdownBlock = function renderMarkdownBlock(blockContent, processor, components, blockOpts) {
+/** markdown 片段 → React 元素 */ var renderMarkdownBlock = function renderMarkdownBlock(blockContent, processor, components) {
     if (!blockContent.trim()) return null;
     try {
         var mdast = processor.parse(blockContent);
         var hast = processor.runSync(mdast);
-        if (blockOpts === null || blockOpts === void 0 ? void 0 : blockOpts.markStreamingTailParagraph) {
-            markLastParagraphStreamingTail(hast);
-        }
         return toJsxRuntime(hast, {
             Fragment: Fragment,
             jsx: jsx,
@@ -1240,10 +1207,7 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
         return null;
     }
 };
-/**
- * 将 markdown 按块（双换行）拆分，尊重代码围栏边界。
- * 返回的每个块是一个独立的 markdown 片段，可单独解析。
- */ var splitMarkdownBlocks = function splitMarkdownBlocks(content) {
+/** 按双换行拆块，尊重代码围栏边界 */ var splitMarkdownBlocks = function splitMarkdownBlocks(content) {
     var lines = content.split('\n');
     var blocks = [];
     var current = [];
@@ -1287,4 +1251,4 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
     }
     return blocks;
 };
-export { buildEditorAlignedComponents, createHastProcessor, markLastParagraphStreamingTail, renderMarkdownBlock, splitMarkdownBlocks };
+export { buildEditorAlignedComponents, createHastProcessor, renderMarkdownBlock, splitMarkdownBlocks };

package/dist/MarkdownRenderer/renderers/ChartRenderer.js

@@ -284,15 +284,23 @@ var extractTextContent = function extractTextContent1(children) {
     useEffect(function() {
         // 延迟一帧渲染图表，确保容器已挂载到 DOM 且有正确的宽度
         // 解决 recharts ResponsiveContainer 在零宽容器中崩溃的问题
+        var cancelled = false;
         var raf = requestAnimationFrame(function() {
+            if (cancelled) {
+                return;
+            }
             setMounted(true);
         });
         return function() {
-            return cancelAnimationFrame(raf);
+            cancelled = true;
+            cancelAnimationFrame(raf);
         };
     }, []);
     useEffect(function() {
         if (!mounted) return;
+        if (typeof window === 'undefined') {
+            return;
+        }
         var updateWidth = function updateWidth() {
             var _containerRef_current;
             var width = ((_containerRef_current = containerRef.current) === null || _containerRef_current === void 0 ? void 0 : _containerRef_current.clientWidth) || 400;

package/dist/MarkdownRenderer/streaming/MarkdownBlockPiece.d.ts

@@ -1,15 +1,13 @@
 import type { Processor } from 'unified';
 import React from 'react';
 export interface MarkdownBlockPieceProps {
-    /** 末块为 tail（生长中）；一旦其后出现新块，同一段内容变为 sealed，保持同一 React key 可避免重组件卸载 */
     variant: 'sealed' | 'tail';
     blockSource: string;
     processor: Processor;
     components: Record<string, any>;
-    /** 仅末块且处于流式模式时为 true，用于节流与末段动画 */
     streaming: boolean;
 }
 /**
- * 统一的块级渲染：封版与末块使用同一组件类型；按 blockSource 缓存解析结果引用，使 tail→sealed 时与旧 Map 缓存一样复用同一棵 React 子树。
+ * 块级渲染单元：sealed 块缓存不动，tail 块节流重解析 + 闪烁光标。
  */
 export declare const MarkdownBlockPiece: React.NamedExoticComponent<MarkdownBlockPieceProps>;

package/dist/MarkdownRenderer/streaming/MarkdownBlockPiece.js

@@ -1,49 +1,37 @@
 import React, { memo, useMemo, useRef } from "react";
 import { renderMarkdownBlock } from "../markdownReactShared";
 import { StreamingAnimationContext } from "../StreamingAnimationContext";
+import { StreamingCursor } from "../StreamingCursor";
 import { shouldReparseLastBlock } from "./lastBlockThrottle";
 /**
- * 统一的块级渲染：封版与末块使用同一组件类型；按 blockSource 缓存解析结果引用，使 tail→sealed 时与旧 Map 缓存一样复用同一棵 React 子树。
+ * 块级渲染单元：sealed 块缓存不动，tail 块节流重解析 + 闪烁光标。
  */ export var MarkdownBlockPiece = /*#__PURE__*/ memo(function MarkdownBlockPiece(param) {
     var variant = param.variant, blockSource = param.blockSource, processor = param.processor, components = param.components, streaming = param.streaming;
     var lastParsedRef = useRef(null);
-    /** 完整 parse 结果缓存：键为 block 源串，供 sealed 与 tail 晋升时复用同一引用 */ var parseBySourceRef = useRef(new Map());
+    var cacheRef = useRef(new Map());
     var node = useMemo(function() {
-        var cached = parseBySourceRef.current.get(blockSource);
-        if (cached && variant === 'sealed') {
-            return cached;
-        }
-        if (variant === 'sealed') {
-            var el = renderMarkdownBlock(blockSource, processor, components, {
-                markStreamingTailParagraph: false
-            });
-            parseBySourceRef.current.set(blockSource, el);
-            return el;
-        }
-        if (!streaming) {
-            var el1 = renderMarkdownBlock(blockSource, processor, components, {
-                markStreamingTailParagraph: false
-            });
-            parseBySourceRef.current.set(blockSource, el1);
-            lastParsedRef.current = {
+        var cached = cacheRef.current.get(blockSource);
+        if (cached && variant === 'sealed') return cached;
+        if (variant === 'sealed' || !streaming) {
+            var el = renderMarkdownBlock(blockSource, processor, components);
+            cacheRef.current.set(blockSource, el);
+            if (variant === 'tail') lastParsedRef.current = {
                 source: blockSource,
-                node: el1
+                node: el
             };
-            return el1;
+            return el;
         }
         var prev = lastParsedRef.current;
         if (prev && !shouldReparseLastBlock(prev.source, blockSource, true)) {
             return prev.node;
         }
-        var el2 = renderMarkdownBlock(blockSource, processor, components, {
-            markStreamingTailParagraph: true
-        });
-        parseBySourceRef.current.set(blockSource, el2);
+        var el1 = renderMarkdownBlock(blockSource, processor, components);
+        cacheRef.current.set(blockSource, el1);
         lastParsedRef.current = {
             source: blockSource,
-            node: el2
+            node: el1
         };
-        return el2;
+        return el1;
     }, [
         variant,
         blockSource,
@@ -56,6 +44,6 @@ import { shouldReparseLastBlock } from "./lastBlockThrottle";
         value: {
             animateBlock: animateBlock
         }
-    }, node);
+    }, node, animateBlock && /*#__PURE__*/ React.createElement(StreamingCursor, null));
 });
 MarkdownBlockPiece.displayName = 'MarkdownBlockPiece';

package/dist/MarkdownRenderer/style.js

@@ -42,6 +42,24 @@ export var useRendererVarStyle = function useRendererVarStyle(prefixCls) {
                 transform: 'translateY(0)',
                 filter: 'blur(0px)'
             }
+        }), _define_property(_obj, '@keyframes markdownStreamingCursorBlink', {
+            '0%, 100%': {
+                opacity: 0.9,
+                boxShadow: '0 0 4px currentColor'
+            },
+            '50%': {
+                opacity: 0,
+                boxShadow: '0 0 0 currentColor'
+            }
+        }), _define_property(_obj, '@keyframes markdownStreamingCursorFadeIn', {
+            from: {
+                opacity: 0,
+                transform: 'scaleY(0.3)'
+            },
+            to: {
+                opacity: 0.9,
+                transform: 'scaleY(1)'
+            }
         }), _obj;
     });
 };