@agentscope-ai/chat 1.1.17 → 1.1.19-beta.1761468580294

package/lib/Accordion/Accordion.d.ts

@@ -45,6 +45,11 @@ export interface IAccordionProps {
      * @descriptionEn Whether the component is expanded by default when initialized
      */
     defaultOpen?: boolean;
+    /**
+     * @description 受控模式：控制组件是否展开
+     * @descriptionEn Controlled mode: controls whether the component is expanded
+     */
+    open?: boolean;
     /**
      * @description 内容区域的样式对象
      * @descriptionEn Style object for the content area

package/lib/Accordion/Accordion.js

@@ -29,7 +29,10 @@ function Item(props) {
     _React$useState2 = _slicedToArray(_React$useState, 2),
     stateOpen = _React$useState2[0],
     setStateOpen = _React$useState2[1];
-  var status = props.inline ? 'close' : stateOpen ? 'open' : 'close';
+
+  // 支持受控模式：如果提供了 open prop，则使用它；否则使用内部状态
+  var isOpen = props.open !== undefined ? props.open : stateOpen;
+  var status = props.inline ? 'close' : isOpen ? 'open' : 'close';
   var icon = useMemo(function () {
     if (props.icon) return props.icon;
     if (props.status === 'generating') return /*#__PURE__*/_jsx(SparkLoadingLine, {
@@ -65,7 +68,7 @@ function Item(props) {
     children: [/*#__PURE__*/_jsxs("div", {
       className: cls("".concat(prefixCls, "-header"), "".concat(prefixCls, "-header-").concat(status)),
       onClick: function onClick() {
-        return content && setStateOpen(!stateOpen);
+        return content && props.open === undefined && setStateOpen(!stateOpen);
       },
       children: [icon ? /*#__PURE__*/_jsx("div", {
         className: cls("".concat(prefixCls, "-header-icon"), _defineProperty(_defineProperty(_defineProperty({}, "".concat(prefixCls, "-header-icon-line"), props.iconLine), "".concat(prefixCls, "-header-icon-first"), props.isFirst), "".concat(prefixCls, "-header-icon-last"), props.isLast && status === 'close' || props.level)),
@@ -74,7 +77,7 @@ function Item(props) {
         children: props.title
       }), content && /*#__PURE__*/_jsx("div", {
         className: cls("".concat(prefixCls, "-header-arrow")),
-        children: !stateOpen ? /*#__PURE__*/_jsx(SparkDownLine, {}) : /*#__PURE__*/_jsx(SparkUpLine, {})
+        children: !isOpen ? /*#__PURE__*/_jsx(SparkDownLine, {}) : /*#__PURE__*/_jsx(SparkUpLine, {})
       }), /*#__PURE__*/_jsxs(_Fragment, {
         children: [/*#__PURE__*/_jsx("span", {
           style: {
@@ -84,7 +87,7 @@ function Item(props) {
       })]
     }), /*#__PURE__*/_jsx(Children, {
       prefixCls: prefixCls,
-      stateOpen: stateOpen,
+      stateOpen: isOpen,
       status: status,
       inline: props.inline,
       content: content,

package/lib/Accordion/DeepThinking.d.ts

@@ -19,6 +19,21 @@ export interface IDeepThinking {
      * @descriptionEn Whether to expand by default when component initializes, controls initial display state
      */
     defaultOpen?: boolean;
+    /**
+     * @description 受控模式：控制组件是否展开
+     * @descriptionEn Controlled mode: controls whether the component is expanded
+     */
+    open?: boolean;
+    /**
+     * @description 生成结束后是否自动关闭（默认 false）
+     * @descriptionEn Whether to automatically close after generation is complete (default false)
+     */
+    autoCloseOnFinish?: boolean;
+    /**
+     * @description 内容区域的最大高度（单位：像素）
+     * @descriptionEn Maximum height of the content area (in pixels)
+     */
+    maxHeight?: number;
     /**
      * @description 组件的CSS类名，用于自定义样式
      * @descriptionEn CSS class name for the component for custom styling

package/lib/Accordion/DeepThinking.js

@@ -5,10 +5,10 @@ import cls from 'classnames';
 import { jsx as _jsx } from "react/jsx-runtime";
 export default function (props) {
   var _useProviderContext = useProviderContext(),
-    theme = _useProviderContext.theme,
+    providerTheme = _useProviderContext.theme,
     getPrefixCls = _useProviderContext.getPrefixCls;
   var prefixCls = getPrefixCls('accordion-deep-thinking');
-  var isDarkMode = (theme === null || theme === void 0 ? void 0 : theme.algorithm) === AntdTheme.darkAlgorithm;
+  var isDarkMode = (providerTheme === null || providerTheme === void 0 ? void 0 : providerTheme.algorithm) === AntdTheme.darkAlgorithm;
   var icon = /*#__PURE__*/_jsx("img", {
     style: {
       display: 'block',
@@ -18,14 +18,33 @@ export default function (props) {
     },
     src: "https://img.alicdn.com/imgextra/i2/O1CN01QZgWRv1I4JM0BAZ9O_!!6000000000839-54-tps-56-56.apng"
   });
-  var title = "".concat(props.title || 'Deep thinking').concat(props.loading ? '...' : '');
+
+  // 构建标题文本
+  var titleText = props.title || 'Deep thinking';
+  if (props.loading) {
+    titleText += '...';
+  }
+
+  // 构建标题
+  var title = props.loading ? /*#__PURE__*/_jsx(Accordion.SoftLightTitle, {
+    children: titleText
+  }) : titleText;
+
+  // 构建 bodyStyle，添加 maxHeight 支持
+  var bodyStyle = props.maxHeight ? {
+    maxHeight: props.maxHeight,
+    overflowY: 'auto'
+  } : {};
+
+  // 确定默认展开状态：如果设置了 autoCloseOnFinish 且不在 loading 状态，默认关闭
+  var finalDefaultOpen = props.defaultOpen !== undefined ? props.defaultOpen : props.autoCloseOnFinish && !props.loading ? false : undefined;
   return /*#__PURE__*/_jsx(Accordion, {
-    title: props.loading ? /*#__PURE__*/_jsx(Accordion.SoftLightTitle, {
-      children: title
-    }) : title,
+    title: title,
     status: props.loading ? 'generating' : 'finished',
     icon: props.loading ? icon : null,
-    defaultOpen: props.defaultOpen,
+    defaultOpen: finalDefaultOpen,
+    open: props.open,
+    bodyStyle: bodyStyle,
     inline: true,
     children: /*#__PURE__*/_jsx("div", {
       className: cls(prefixCls, props.className),

package/lib/DefaultCards/DeepThinking/index.d.ts

@@ -6,6 +6,10 @@ interface IProps {
         loading?: boolean;
         content?: string;
         className?: string;
+        defaultOpen?: boolean;
+        open?: boolean;
+        autoCloseOnFinish?: boolean;
+        maxHeight?: number;
     };
 }
 export default function (props: IProps): import("react/jsx-runtime").JSX.Element;

package/lib/DefaultCards/DeepThinking/index.js

@@ -3,10 +3,13 @@ import { DeepThinking } from "../..";
 import { jsx as _jsx } from "react/jsx-runtime";
 export default function (props) {
   return /*#__PURE__*/_jsx(DeepThinking, {
-    defaultOpen: true,
+    defaultOpen: props.data.defaultOpen !== undefined ? props.data.defaultOpen : true,
     title: props.data.title,
     loading: props.data.loading,
     content: props.data.content,
-    className: props.data.className
+    className: props.data.className,
+    open: props.data.open,
+    autoCloseOnFinish: props.data.autoCloseOnFinish,
+    maxHeight: props.data.maxHeight
   });
 }

package/lib/DefaultCards/Text/index.js

@@ -9,7 +9,9 @@ import { Markdown } from "../..";
 import { jsx as _jsx } from "react/jsx-runtime";
 export default function (props) {
   var cursor = props.data.msgStatus === 'generating';
-  return /*#__PURE__*/_jsx(Markdown, _objectSpread({
+  return /*#__PURE__*/_jsx(Markdown, _objectSpread(_objectSpread({
     cursor: cursor
-  }, props.data));
+  }, props.data), {}, {
+    typing: props.data.msgStatus === 'generating' ? props.data.typing : false
+  }));
 }

package/lib/ImageGenerator/index.js

@@ -3,7 +3,7 @@ import Style from "./style";
 import { useProviderContext } from "../Provider";
 import { ConfigProvider, Image } from 'antd';
 import { SparkCheckCircleFill } from '@agentscope-ai/icons';
-import Dot from "../Markdown/cursor/Dot";
+import Dot from "../Markdown/plugins/cursor/Dot";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 import { Fragment as _Fragment } from "react/jsx-runtime";

package/lib/Markdown/Markdown/AnimationNode.d.ts

@@ -0,0 +1,20 @@
+import type { DOMNode } from 'html-react-parser';
+import React from 'react';
+import { HTMLTag } from './hooks/useAnimation';
+import { AnimationConfig } from './interface';
+export interface AnimationNodeProps extends React.HTMLAttributes<HTMLElement> {
+    children?: React.ReactNode | React.ReactNode[];
+    nodeTag: HTMLTag;
+    animationConfig?: AnimationConfig;
+    streamStatus?: 'loading' | 'done';
+    domNode?: DOMNode;
+    [key: string]: unknown;
+}
+export interface AnimationTextProps {
+    text: string;
+    animationConfig?: AnimationConfig;
+}
+declare const AnimationText: React.NamedExoticComponent<AnimationTextProps>;
+declare const AnimationNode: React.FC<AnimationNodeProps>;
+export default AnimationNode;
+export { AnimationText };

package/lib/Markdown/Markdown/AnimationNode.js

@@ -0,0 +1,84 @@
+var _excluded = ["nodeTag", "children", "animationConfig", "domNode", "streamStatus"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { 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 _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(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(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import React, { useEffect, useRef, useState } from 'react';
+import { useProviderContext } from "../..";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+var AnimationText = /*#__PURE__*/React.memo(function (props) {
+  var text = props.text,
+    animationConfig = props.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-in-out' : _ref$easing;
+  var _useState = useState([]),
+    _useState2 = _slicedToArray(_useState, 2),
+    chunks = _useState2[0],
+    setChunks = _useState2[1];
+  var prevTextRef = useRef('');
+  var _useProviderContext = useProviderContext(),
+    getPrefixCls = _useProviderContext.getPrefixCls;
+  var prefixCls = getPrefixCls('markdown');
+  useEffect(function () {
+    if (text === prevTextRef.current) return;
+    if (!(prevTextRef.current && text.indexOf(prevTextRef.current) === 0)) {
+      setChunks([text]);
+      prevTextRef.current = text;
+      return;
+    }
+    var newText = text.slice(prevTextRef.current.length);
+    if (!newText) return;
+    setChunks(function (prev) {
+      return [].concat(_toConsumableArray(prev), [newText]);
+    });
+    prevTextRef.current = text;
+  }, [text]);
+  return /*#__PURE__*/_jsx(_Fragment, {
+    children: chunks.map(function (text, index) {
+      return /*#__PURE__*/_jsx("span", {
+        style: {
+          animation: "".concat(prefixCls, "-fadeIn ").concat(fadeDuration, "ms ").concat(easing, " forwards")
+        },
+        children: text
+      }, "".concat(index, "-").concat(text));
+    })
+  });
+});
+var AnimationNode = function AnimationNode(props) {
+  var nodeTag = props.nodeTag,
+    children = props.children,
+    animationConfig = props.animationConfig,
+    domNode = props.domNode,
+    streamStatus = props.streamStatus,
+    restProps = _objectWithoutProperties(props, _excluded);
+  var renderChildren = function renderChildren() {
+    if (!children) return null;
+    if (Array.isArray(children)) {
+      return children.map(function (child, index) {
+        return typeof child === 'string' ? /*#__PURE__*/_jsx(AnimationText, {
+          animationConfig: animationConfig,
+          text: child
+        }, index) : child;
+      });
+    }
+    return typeof children === 'string' ? /*#__PURE__*/_jsx(AnimationText, {
+      text: children,
+      animationConfig: animationConfig
+    }) : children;
+  };
+  return /*#__PURE__*/React.createElement(nodeTag, restProps, renderChildren());
+};
+export default AnimationNode;
+export { AnimationText };

package/lib/Markdown/Markdown/Markdown.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { MarkdownProps } from './interface';
+declare const Markdown: React.FC<MarkdownProps>;
+export default Markdown;

package/lib/Markdown/Markdown/Markdown.js

@@ -0,0 +1,58 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import classnames from 'classnames';
+import React from 'react';
+import { Parser, Renderer } from "./core";
+import { useAnimation, useStreaming } from "./hooks";
+import Style from "./style";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var Markdown = function Markdown(props) {
+  var cursor = props.cursor,
+    baseFontSize = props.baseFontSize,
+    baseLineHeight = props.baseLineHeight,
+    streaming = props.streaming,
+    config = props.config,
+    components = props.components,
+    _props$paragraphTag = props.paragraphTag,
+    paragraphTag = _props$paragraphTag === void 0 ? 'p' : _props$paragraphTag,
+    content = props.content,
+    children = props.children,
+    rootClassName = props.rootClassName,
+    className = props.className,
+    style = props.style,
+    openLinksInNewTab = props.openLinksInNewTab,
+    dompurifyConfig = props.dompurifyConfig;
+  var mergedCls = classnames(rootClassName, className);
+  var mergedStyle = _objectSpread({
+    fontSize: baseFontSize,
+    lineHeight: baseLineHeight
+  }, style);
+  var displayContent = useStreaming(content || children || '', streaming, cursor);
+  var animationComponents = useAnimation(streaming);
+  if (!displayContent) return null;
+  var parser = new Parser({
+    markedConfig: config,
+    paragraphTag: paragraphTag,
+    openLinksInNewTab: openLinksInNewTab
+  });
+  var renderComponents = _objectSpread(_objectSpread({}, animationComponents), components || {});
+  var renderer = new Renderer({
+    components: renderComponents,
+    dompurifyConfig: dompurifyConfig
+  });
+  var htmlString = parser.parse(displayContent);
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx(Style, {}), /*#__PURE__*/_jsx("div", {
+      className: mergedCls,
+      style: mergedStyle,
+      children: renderer.render(htmlString)
+    })]
+  });
+};
+export default Markdown;

package/lib/Markdown/Markdown/core/Parser.d.ts

@@ -0,0 +1,16 @@
+import { Marked } from 'marked';
+import { MarkdownProps } from '../interface';
+type ParserOptions = {
+    markedConfig?: MarkdownProps['config'];
+    paragraphTag?: string;
+    openLinksInNewTab?: boolean;
+};
+declare class Parser {
+    options: ParserOptions;
+    markdownInstance: Marked;
+    constructor(options?: ParserOptions);
+    private configureRenderer;
+    configureParagraph(): void;
+    parse(content: string): string;
+}
+export default Parser;

package/lib/Markdown/Markdown/core/Parser.js

@@ -0,0 +1,64 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { Marked } from 'marked';
+var Parser = /*#__PURE__*/function () {
+  function Parser() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, Parser);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "markdownInstance", void 0);
+    var _options$markedConfig = options.markedConfig,
+      markedConfig = _options$markedConfig === void 0 ? {} : _options$markedConfig,
+      openLinksInNewTab = options.openLinksInNewTab;
+    this.options = options;
+    this.markdownInstance = new Marked(markedConfig);
+    this.configureRenderer(openLinksInNewTab);
+    this.configureParagraph();
+  }
+  _createClass(Parser, [{
+    key: "configureRenderer",
+    value: function configureRenderer(openLinksInNewTab) {
+      if (!openLinksInNewTab) return;
+      var renderer = {
+        link: function link(_ref) {
+          var href = _ref.href,
+            title = _ref.title,
+            tokens = _ref.tokens;
+          var text = this.parser.parseInline(tokens);
+          var titleAttr = title ? " title=\"".concat(title, "\"") : '';
+          return "<a href=\"".concat(href, "\"").concat(titleAttr, " target=\"_blank\" rel=\"noopener noreferrer\">").concat(text, "</a>");
+        }
+      };
+      this.markdownInstance.use({
+        renderer: renderer
+      });
+    }
+  }, {
+    key: "configureParagraph",
+    value: function configureParagraph() {
+      var paragraphTag = this.options.paragraphTag;
+      if (!paragraphTag) return;
+      var renderer = {
+        paragraph: function paragraph(_ref2) {
+          var tokens = _ref2.tokens;
+          return "<".concat(paragraphTag, ">").concat(this.parser.parseInline(tokens), "</").concat(paragraphTag, ">\n");
+        }
+      };
+      this.markdownInstance.use({
+        renderer: renderer
+      });
+    }
+  }, {
+    key: "parse",
+    value: function parse(content) {
+      return this.markdownInstance.parse(content);
+    }
+  }]);
+  return Parser;
+}();
+export default Parser;

package/lib/Markdown/Markdown/core/Renderer.d.ts

@@ -0,0 +1,24 @@
+import type { Config as DOMPurifyConfig } from 'dompurify';
+import React, { ReactNode } from 'react';
+import type { MarkdownProps } from '../interface';
+interface RendererOptions {
+    components?: MarkdownProps['components'];
+    dompurifyConfig?: DOMPurifyConfig;
+}
+declare class Renderer {
+    private readonly options;
+    constructor(options: RendererOptions);
+    /**
+     * Detect unclosed tags using regular expressions
+     */
+    private detectUnclosedTags;
+    /**
+     * Configure DOMPurify to preserve components and target attributes, filter everything else
+     */
+    private configureDOMPurify;
+    private replaceElement;
+    private processChildren;
+    processHtml(htmlString: string): React.ReactNode;
+    render(html: string): ReactNode | null;
+}
+export default Renderer;

package/lib/Markdown/Markdown/core/Renderer.js

@@ -0,0 +1,137 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { 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 _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(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(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _classCallCheck(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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import parseHtml, { domToReact } from 'html-react-parser';
+import React from 'react';
+var Renderer = /*#__PURE__*/function () {
+  function Renderer(options) {
+    _classCallCheck(this, Renderer);
+    _defineProperty(this, "options", void 0);
+    this.options = options;
+  }
+
+  /**
+   * Detect unclosed tags using regular expressions
+   */
+  _createClass(Renderer, [{
+    key: "detectUnclosedTags",
+    value: function detectUnclosedTags(htmlString) {
+      var unclosedTags = new Set();
+      var stack = [];
+      var tagRegex = /<\/?([a-zA-Z][a-zA-Z0-9-]*)(?:\s[^>]*)?>/g;
+      var match = tagRegex.exec(htmlString);
+      while (match !== null) {
+        var _this$options$compone;
+        var _match = match,
+          _match2 = _slicedToArray(_match, 2),
+          fullMatch = _match2[0],
+          tagName = _match2[1];
+        var isClosing = fullMatch.startsWith('</');
+        var isSelfClosing = fullMatch.endsWith('/>');
+        if ((_this$options$compone = this.options.components) !== null && _this$options$compone !== void 0 && _this$options$compone[tagName.toLowerCase()]) {
+          if (isClosing) {
+            // Found closing tag, pop from stack
+            var lastIndex = stack.lastIndexOf(tagName.toLowerCase());
+            if (lastIndex !== -1) {
+              stack.splice(lastIndex, 1);
+            }
+          } else if (!isSelfClosing) {
+            // Found opening tag, push to stack
+            stack.push(tagName.toLowerCase());
+          }
+        }
+        match = tagRegex.exec(htmlString);
+      }
+
+      // Remaining tags in stack are unclosed
+      stack.forEach(function (tag) {
+        unclosedTags.add(tag);
+      });
+      return unclosedTags;
+    }
+
+    /**
+     * Configure DOMPurify to preserve components and target attributes, filter everything else
+     */
+  }, {
+    key: "configureDOMPurify",
+    value: function configureDOMPurify() {
+      var customComponents = Object.keys(this.options.components || {});
+      var userConfig = this.options.dompurifyConfig || {};
+      return _objectSpread(_objectSpread({}, userConfig), {}, {
+        ADD_TAGS: _toConsumableArray(new Set([].concat(customComponents, _toConsumableArray(userConfig.ALLOWED_TAGS || []))))
+      });
+    }
+  }, {
+    key: "replaceElement",
+    value: function replaceElement(unclosedTags) {
+      var _this = this;
+      return function (domNode) {
+        var _this$options$compone2;
+        if (!('name' in domNode)) return;
+        var _ref = domNode,
+          name = _ref.name,
+          attribs = _ref.attribs,
+          children = _ref.children;
+        var renderElement = (_this$options$compone2 = _this.options.components) === null || _this$options$compone2 === void 0 ? void 0 : _this$options$compone2[name];
+        if (renderElement) {
+          var streamStatus = unclosedTags !== null && unclosedTags !== void 0 && unclosedTags.has(name) ? 'loading' : 'done';
+          var props = _objectSpread({
+            domNode: domNode,
+            streamStatus: streamStatus
+          }, attribs);
+
+          // Handle class and className merging
+          var classes = [props.className, props.classname, props.class].filter(Boolean).join(' ').trim();
+          props.className = classes || '';
+          if (children) {
+            props.children = _this.processChildren(children, unclosedTags);
+          }
+          return /*#__PURE__*/React.createElement(renderElement, props);
+        }
+      };
+    }
+  }, {
+    key: "processChildren",
+    value: function processChildren(children, unclosedTags) {
+      return domToReact(children, {
+        replace: this.replaceElement(unclosedTags)
+      });
+    }
+  }, {
+    key: "processHtml",
+    value: function processHtml(htmlString) {
+      var unclosedTags = this.detectUnclosedTags(htmlString);
+      // Use DOMPurify to clean HTML while preserving custom components and target attributes
+      // const purifyConfig = this.configureDOMPurify();
+      // const cleanHtml = DOMPurify.sanitize(htmlString, purifyConfig);
+
+      return parseHtml(htmlString, {
+        replace: this.replaceElement(unclosedTags)
+      });
+    }
+  }, {
+    key: "render",
+    value: function render(html) {
+      return this.processHtml(html);
+    }
+  }]);
+  return Renderer;
+}();
+export default Renderer;

package/lib/Markdown/Markdown/core/index.d.ts

@@ -0,0 +1,3 @@
+import Parser from './Parser';
+import Renderer from './Renderer';
+export { Parser, Renderer };

package/lib/Markdown/Markdown/core/index.js

@@ -0,0 +1,3 @@
+import Parser from "./Parser";
+import Renderer from "./Renderer";
+export { Parser, Renderer };

package/lib/Markdown/{CodeBlock.js → Markdown/defaultComponents/CodeBlock.js}

@@ -6,10 +6,10 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 function _arrayLikeToArray(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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-import React, { useState } from 'react';
+import React, { useMemo, useState } from 'react';
 import { CodeBlock as Code, CodeBlockLangExtensionsMap } from "@agentscope-ai/design";
 import { createStyles } from 'antd-style';
-import { useProviderContext, Mermaid } from "./..";
+import { useProviderContext, Mermaid } from "../../..";
 import { theme as AntdTheme } from 'antd';
 import { SparkCopyLine, SparkTrueLine } from '@agentscope-ai/icons';
 import { jsx as _jsx } from "react/jsx-runtime";
@@ -51,11 +51,14 @@ var CodeBlock = function CodeBlock(_ref) {
     copied = _useState2[0],
     setCopied = _useState2[1];
   var _code$content = code.content,
-    content = _code$content === void 0 ? '' : _code$content,
+    _content = _code$content === void 0 ? '' : _code$content,
     _code$lang = code.lang,
     lang = _code$lang === void 0 ? '' : _code$lang;
+  var content = useMemo(function () {
+    return _content.replace(/ :(dot|underline):/g, '');
+  }, [_content]);
   if (!content) return null;
-  if (enableMermaid && lang === 'mermaid') {
+  if (lang === 'mermaid') {
     return /*#__PURE__*/_jsx(Mermaid, {
       content: content,
       width: "50%"