@ant-design/agentic-ui 2.29.59 → 2.30.1

package/dist/MarkdownRenderer/AnimationText.js

@@ -0,0 +1,226 @@
+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 _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(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 _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 _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 React, { useEffect, useMemo, useRef, useState } from "react";
+/**
+ * 提取 React children 的纯文本
+ */ var extractText = function extractText1(children) {
+    var _children_props;
+    if (typeof children === 'string') return children;
+    if (typeof children === 'number') return String(children);
+    if (Array.isArray(children)) return children.map(extractText).join('');
+    if (/*#__PURE__*/ React.isValidElement(children) && ((_children_props = children.props) === null || _children_props === void 0 ? void 0 : _children_props.children)) {
+        return extractText(children.props.children);
+    }
+    return '';
+};
+/**
+ * 识别 children 中是否包含 React 元素节点。
+ * 富文本结构（链接、脚注、图片等）在纯文本差分下会丢失结构信息，直接透传更安全。
+ */ var hasElementNode = function hasElementNode1(children) {
+    if (children === null || children === undefined || typeof children === 'boolean') return false;
+    if (typeof children === 'string' || typeof children === 'number') return false;
+    if (Array.isArray(children)) return children.some(hasElementNode);
+    return /*#__PURE__*/ React.isValidElement(children);
+};
+/**
+ * 流式文字淡入动画组件。
+ *
+ * 采用 opacity + translateY（GPU 硬件加速），清爽流派。
+ * 动画结束后通过 animationend 标记 done，仍用 span 包裹以保持布局稳定。
+ */ 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 ? 200 : _ref_fadeDuration, _ref_easing = _ref.easing, easing = _ref_easing === void 0 ? 'ease-out' : _ref_easing;
+    var _useState = _sliced_to_array(useState([]), 2), chunks = _useState[0], setChunks = _useState[1];
+    var prevTextRef = useRef('');
+    var text = extractText(children);
+    var hasElementContent = hasElementNode(children);
+    useEffect(function() {
+        if (hasElementContent) {
+            prevTextRef.current = text;
+            return;
+        }
+        if (text === prevTextRef.current) return;
+        if (!prevTextRef.current || !text.startsWith(prevTextRef.current)) {
+            setChunks([
+                {
+                    key: '0',
+                    text: text,
+                    content: children,
+                    done: false
+                }
+            ]);
+            prevTextRef.current = text;
+            return;
+        }
+        var prevLen = prevTextRef.current.length;
+        var newText = text.slice(prevLen);
+        var newKey = "anim-".concat(Date.now(), "-").concat(prevLen);
+        setChunks(function(prev) {
+            return _to_consumable_array(prev).concat([
+                {
+                    key: newKey,
+                    text: newText,
+                    done: false
+                }
+            ]);
+        });
+        prevTextRef.current = text;
+    }, [
+        text,
+        children,
+        hasElementContent
+    ]);
+    var handleAnimationEnd = function handleAnimationEnd(key) {
+        setChunks(function(prev) {
+            return prev.map(function(c) {
+                return c.key === key ? _object_spread_props(_object_spread({}, c), {
+                    done: true
+                }) : c;
+            });
+        });
+    };
+    var animationStyle = useMemo(function() {
+        return {
+            display: 'inline-block',
+            animation: "markdownRendererSlideFadeIn ".concat(fadeDuration, "ms ").concat(easing, " forwards"),
+            willChange: 'opacity, transform',
+            color: 'inherit'
+        };
+    }, [
+        fadeDuration,
+        easing
+    ]);
+    /** 动画结束后仍用 inline-block 包裹，避免从 span 变为裸内容时的宽度重排 */ var doneChunkStyle = useMemo(function() {
+        return {
+            display: 'inline-block',
+            color: 'inherit'
+        };
+    }, []);
+    if (hasElementContent) {
+        return /*#__PURE__*/ React.createElement(React.Fragment, null, children);
+    }
+    return /*#__PURE__*/ React.createElement(React.Fragment, null, chunks.map(function(chunk) {
+        var _chunk_content;
+        var rendered = (_chunk_content = chunk.content) !== null && _chunk_content !== void 0 ? _chunk_content : chunk.text;
+        return chunk.done ? /*#__PURE__*/ React.createElement("span", {
+            key: chunk.key,
+            style: doneChunkStyle
+        }, rendered) : /*#__PURE__*/ React.createElement("span", {
+            key: chunk.key,
+            style: animationStyle,
+            onAnimationEnd: function onAnimationEnd() {
+                return handleAnimationEnd(chunk.key);
+            }
+        }, rendered);
+    }));
+});
+AnimationText.displayName = 'AnimationText';
+export default AnimationText;

package/dist/MarkdownRenderer/CharacterQueue.d.ts

@@ -0,0 +1,36 @@
+import type { CharacterQueueOptions } from './types';
+/**
+ * 字符队列——流式渲染的调度核心。
+ *
+ * - 接收 SSE 推送的 content（完整字符串，非增量）
+ * - 标签页可见时以 RAF 驱动逐字输出（60fps 动画）
+ * - 标签页不可见时降级为 setTimeout，保证后台仍能消费
+ * - 切回前台时自动恢复 RAF
+ */
+export declare class CharacterQueue {
+    private displayedLength;
+    private fullContent;
+    private rafId;
+    private timerId;
+    private tickMode;
+    private onFlush;
+    private options;
+    private disposed;
+    constructor(onFlush: (displayed: string) => void, options?: CharacterQueueOptions);
+    /** SSE token 到达时调用——接收完整的 content 字符串 */
+    push(content: string): void;
+    /** 标记流式完成，flush 所有剩余内容 */
+    complete(): void;
+    /** 释放资源 */
+    dispose(): void;
+    /** 当前已展示的长度 */
+    getDisplayedLength(): number;
+    /** 完整内容 */
+    getFullContent(): string;
+    private ensureTicking;
+    private tick;
+    private scheduleNext;
+    private handleVisibilityChange;
+    private isTickActive;
+    private cancelAllTicks;
+}

package/dist/MarkdownRenderer/CharacterQueue.js

@@ -0,0 +1,188 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+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;
+}
+var DEFAULT_CHARS_PER_FRAME = 3;
+var DEFAULT_SPEED = 1.0;
+var DEFAULT_BACKGROUND_INTERVAL = 100;
+var DEFAULT_BACKGROUND_BATCH_MULTIPLIER = 10;
+/**
+ * 字符队列——流式渲染的调度核心。
+ *
+ * - 接收 SSE 推送的 content（完整字符串，非增量）
+ * - 标签页可见时以 RAF 驱动逐字输出（60fps 动画）
+ * - 标签页不可见时降级为 setTimeout，保证后台仍能消费
+ * - 切回前台时自动恢复 RAF
+ */ export var CharacterQueue = /*#__PURE__*/ function() {
+    "use strict";
+    function CharacterQueue(onFlush, options) {
+        var _this = this;
+        _class_call_check(this, CharacterQueue);
+        var _ref, _ref1, _ref2, _ref3, _ref4, _ref5;
+        _define_property(this, "displayedLength", 0);
+        _define_property(this, "fullContent", '');
+        _define_property(this, "rafId", null);
+        _define_property(this, "timerId", null);
+        _define_property(this, "tickMode", 'raf');
+        _define_property(this, "onFlush", void 0);
+        _define_property(this, "options", void 0);
+        _define_property(this, "disposed", false);
+        _define_property(this, "tick", function() {
+            _this.rafId = null;
+            _this.timerId = null;
+            if (_this.disposed) return;
+            var remaining = _this.fullContent.length - _this.displayedLength;
+            if (remaining <= 0) return;
+            var isVisible = typeof document !== 'undefined' && document.visibilityState === 'visible';
+            var baseBatch = Math.max(1, Math.ceil(_this.options.charsPerFrame * _this.options.speed));
+            var batchSize = isVisible ? baseBatch : baseBatch * _this.options.backgroundBatchMultiplier;
+            _this.displayedLength = Math.min(_this.displayedLength + batchSize, _this.fullContent.length);
+            _this.onFlush(_this.fullContent.slice(0, _this.displayedLength));
+            if (_this.displayedLength < _this.fullContent.length) {
+                _this.scheduleNext(isVisible);
+            }
+        });
+        this.onFlush = onFlush;
+        this.options = {
+            charsPerFrame: (_ref = options === null || options === void 0 ? void 0 : options.charsPerFrame) !== null && _ref !== void 0 ? _ref : DEFAULT_CHARS_PER_FRAME,
+            animate: (_ref1 = options === null || options === void 0 ? void 0 : options.animate) !== null && _ref1 !== void 0 ? _ref1 : true,
+            speed: (_ref2 = options === null || options === void 0 ? void 0 : options.speed) !== null && _ref2 !== void 0 ? _ref2 : DEFAULT_SPEED,
+            flushOnComplete: (_ref3 = options === null || options === void 0 ? void 0 : options.flushOnComplete) !== null && _ref3 !== void 0 ? _ref3 : true,
+            backgroundInterval: (_ref4 = options === null || options === void 0 ? void 0 : options.backgroundInterval) !== null && _ref4 !== void 0 ? _ref4 : DEFAULT_BACKGROUND_INTERVAL,
+            backgroundBatchMultiplier: (_ref5 = options === null || options === void 0 ? void 0 : options.backgroundBatchMultiplier) !== null && _ref5 !== void 0 ? _ref5 : DEFAULT_BACKGROUND_BATCH_MULTIPLIER
+        };
+        this.handleVisibilityChange = this.handleVisibilityChange.bind(this);
+        if (typeof document !== 'undefined') {
+            document.addEventListener('visibilitychange', this.handleVisibilityChange);
+        }
+    }
+    _create_class(CharacterQueue, [
+        {
+            /** SSE token 到达时调用——接收完整的 content 字符串 */ key: "push",
+            value: function push(content) {
+                this.fullContent = content;
+                if (!this.options.animate) {
+                    this.displayedLength = content.length;
+                    this.onFlush(content);
+                    return;
+                }
+                this.ensureTicking();
+            }
+        },
+        {
+            /** 标记流式完成，flush 所有剩余内容 */ key: "complete",
+            value: function complete() {
+                if (this.options.flushOnComplete) {
+                    this.cancelAllTicks();
+                    this.displayedLength = this.fullContent.length;
+                    this.onFlush(this.fullContent);
+                }
+            }
+        },
+        {
+            /** 释放资源 */ key: "dispose",
+            value: function dispose() {
+                this.disposed = true;
+                this.cancelAllTicks();
+                if (typeof document !== 'undefined') {
+                    document.removeEventListener('visibilitychange', this.handleVisibilityChange);
+                }
+            }
+        },
+        {
+            /** 当前已展示的长度 */ key: "getDisplayedLength",
+            value: function getDisplayedLength() {
+                return this.displayedLength;
+            }
+        },
+        {
+            /** 完整内容 */ key: "getFullContent",
+            value: function getFullContent() {
+                return this.fullContent;
+            }
+        },
+        {
+            key: "ensureTicking",
+            value: // ---- 调度核心 ----
+            function ensureTicking() {
+                if (this.disposed || this.isTickActive()) return;
+                var isVisible = typeof document !== 'undefined' && document.visibilityState === 'visible';
+                this.tickMode = isVisible ? 'raf' : 'timeout';
+                if (this.tickMode === 'raf') {
+                    this.rafId = requestAnimationFrame(this.tick);
+                } else {
+                    this.timerId = setTimeout(this.tick, this.options.backgroundInterval);
+                }
+            }
+        },
+        {
+            key: "scheduleNext",
+            value: function scheduleNext(isVisible) {
+                if (isVisible) {
+                    this.tickMode = 'raf';
+                    this.rafId = requestAnimationFrame(this.tick);
+                } else {
+                    this.tickMode = 'timeout';
+                    this.timerId = setTimeout(this.tick, this.options.backgroundInterval);
+                }
+            }
+        },
+        {
+            key: "handleVisibilityChange",
+            value: function handleVisibilityChange() {
+                if (this.disposed) return;
+                if (this.displayedLength >= this.fullContent.length) return;
+                this.cancelAllTicks();
+                this.ensureTicking();
+            }
+        },
+        {
+            key: "isTickActive",
+            value: function isTickActive() {
+                return this.rafId !== null || this.timerId !== null;
+            }
+        },
+        {
+            key: "cancelAllTicks",
+            value: function cancelAllTicks() {
+                if (this.rafId !== null) {
+                    cancelAnimationFrame(this.rafId);
+                    this.rafId = null;
+                }
+                if (this.timerId !== null) {
+                    clearTimeout(this.timerId);
+                    this.timerId = null;
+                }
+            }
+        }
+    ]);
+    return CharacterQueue;
+}();

package/dist/MarkdownRenderer/MarkdownRenderer.d.ts

@@ -0,0 +1,13 @@
+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）通过组件映射拦截渲染
+ */
+declare const InternalMarkdownRenderer: React.ForwardRefExoticComponent<MarkdownRendererProps & React.RefAttributes<MarkdownRendererRef>>;
+export default InternalMarkdownRenderer;