@ant-design/agentic-ui 2.16.0 → 2.17.0

package/dist/MarkdownEditor/editor/style.js

@@ -402,6 +402,11 @@ var genStyle = function(token) {
                 backgroundColor: 'var(--color-gray-control-fill-secondary)'
             }
         },
+        '[data-be="media-container"], [data-be="image-container"]': {
+            display: 'flex',
+            minWidth: 0,
+            maxWidth: '100%'
+        },
         '@media screen and (max-width: 600px)': {
             h1: {
                 fontSize: '1.5em'

package/dist/MarkdownEditor/editor/types/Table.d.ts

@@ -10,6 +10,7 @@ export interface TableNode {
             rowSpan: number;
             colSpan: number;
         }>;
+        finish?: boolean;
         config?: any;
         columns?: Array<any>;
     };

package/dist/MarkdownEditor/editor/utils/findMatchingClose.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 查找匹配的闭合标记
+ *
+ * 用于流式解析代码块（特别是 Mermaid 代码块）时，判断代码块是否完整。
+ * 通过查找匹配的闭合标记来确定代码块是否已经完成输入。
+ *
+ * @param src - 源字符串
+ * @param startIdx - 开始搜索的索引位置
+ * @param open - 开始标记（如 "```", "$$", "(" 等）
+ * @param close - 结束标记（如 "```", "$$", ")" 等）
+ * @returns 匹配的闭合标记的索引位置，如果未找到则返回 -1
+ *
+ * @example
+ * ```typescript
+ * // 查找代码块的闭合标记
+ * const code = "```javascript\nconsole.log('hello');\n```";
+ * const closeIdx = findMatchingClose(code, 0, "```", "```");
+ * // 返回: 42 (第二个 ``` 的位置)
+ *
+ * // 查找数学公式的闭合标记
+ * const math = "$$\\sum_{i=1}^{n} x_i$$";
+ * const closeIdx = findMatchingClose(math, 0, "$$", "$$");
+ * // 返回: 最后一个 $ 的位置
+ * ```
+ */
+export declare function findMatchingClose(src: string, startIdx: number, open: string, close: string): number;
+/**
+ * 检查代码块是否完整（基于代码内容）
+ * 用于流式输入时判断代码块是否已经完成
+ *
+ * @param code - 代码内容
+ * @param language - 代码语言（如 'mermaid', 'javascript' 等）
+ * @returns 是否可能完整
+ */
+export declare function isCodeBlockLikelyComplete(code: string, language?: string): boolean;
+export default findMatchingClose;

package/dist/MarkdownEditor/editor/utils/findMatchingClose.js

@@ -0,0 +1,158 @@
+/**
+ * 查找匹配的闭合标记
+ *
+ * 用于流式解析代码块（特别是 Mermaid 代码块）时，判断代码块是否完整。
+ * 通过查找匹配的闭合标记来确定代码块是否已经完成输入。
+ *
+ * @param src - 源字符串
+ * @param startIdx - 开始搜索的索引位置
+ * @param open - 开始标记（如 "```", "$$", "(" 等）
+ * @param close - 结束标记（如 "```", "$$", ")" 等）
+ * @returns 匹配的闭合标记的索引位置，如果未找到则返回 -1
+ *
+ * @example
+ * ```typescript
+ * // 查找代码块的闭合标记
+ * const code = "```javascript\nconsole.log('hello');\n```";
+ * const closeIdx = findMatchingClose(code, 0, "```", "```");
+ * // 返回: 42 (第二个 ``` 的位置)
+ *
+ * // 查找数学公式的闭合标记
+ * const math = "$$\\sum_{i=1}^{n} x_i$$";
+ * const closeIdx = findMatchingClose(math, 0, "$$", "$$");
+ * // 返回: 最后一个 $ 的位置
+ * ```
+ */ export function findMatchingClose(src, startIdx, open, close) {
+    var len = src.length;
+    // 特殊处理 $$ 因为它是两个字符的分隔符，不应该被解释为嵌套的括号
+    if (open === '$$' && close === '$$') {
+        var i = startIdx;
+        while(i < len - 1){
+            if (src[i] === '$' && src[i + 1] === '$') {
+                // 确保没有被转义
+                var k = i - 1;
+                var backslashes = 0;
+                while(k >= 0 && src[k] === '\\'){
+                    backslashes++;
+                    k--;
+                }
+                // 如果反斜杠数量是偶数，说明没有被转义
+                if (backslashes % 2 === 0) return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+    var openChar = open[open.length - 1];
+    var closeSeq = close;
+    var depth = 0;
+    var i1 = startIdx;
+    while(i1 < len){
+        // 如果这里有一个未转义的闭合序列
+        if (src.slice(i1, i1 + closeSeq.length) === closeSeq) {
+            var k1 = i1 - 1;
+            var backslashes1 = 0;
+            while(k1 >= 0 && src[k1] === '\\'){
+                backslashes1++;
+                k1--;
+            }
+            // 如果反斜杠数量是偶数，说明没有被转义
+            if (backslashes1 % 2 === 0) {
+                if (depth === 0) return i1;
+                depth--;
+                i1 += closeSeq.length;
+                continue;
+            }
+        }
+        var ch = src[i1];
+        // 跳过转义字符
+        if (ch === '\\') {
+            i1 += 2;
+            continue;
+        }
+        // 如果遇到开始字符，增加深度
+        if (ch === openChar) {
+            depth++;
+        } else if (ch === closeSeq[closeSeq.length - 1]) {
+            if (depth > 0) depth--;
+        }
+        i1++;
+    }
+    return -1;
+}
+/**
+ * 检查字符串中是否有未闭合的括号
+ */ function checkUnclosedBrackets(code) {
+    // 检查圆括号
+    var openParen = findMatchingClose(code, 0, '(', ')');
+    if (openParen === -1 && code.includes('(')) {
+        // 有开括号但没有匹配的闭括号
+        return true;
+    }
+    // 检查方括号
+    var openBracket = findMatchingClose(code, 0, '[', ']');
+    if (openBracket === -1 && code.includes('[')) {
+        return true;
+    }
+    // 检查花括号
+    var openBrace = findMatchingClose(code, 0, '{', '}');
+    if (openBrace === -1 && code.includes('{')) {
+        return true;
+    }
+    return false;
+}
+/**
+ * 检查 Mermaid 代码是否完整
+ */ function isMermaidCodeComplete(code) {
+    // 检查是否包含基本的 Mermaid 图表类型关键字
+    var hasChartType = code.includes('graph') || code.includes('sequenceDiagram') || code.includes('gantt') || code.includes('pie') || code.includes('classDiagram') || code.includes('stateDiagram') || code.includes('erDiagram') || code.includes('journey') || code.includes('gitgraph') || code.includes('flowchart');
+    if (!hasChartType) return false;
+    // 检查基本结构完整性
+    if (code.length < 10) return false;
+    // 检查括号匹配
+    var hasUnclosedBrackets = checkUnclosedBrackets(code);
+    if (hasUnclosedBrackets) return false;
+    // 检查是否以常见的不完整模式结尾
+    var incompletePatterns = [
+        /graph\s*$/i,
+        /-->?\s*$/
+    ];
+    var endsWithIncomplete = incompletePatterns.some(function(pattern) {
+        return pattern.test(code);
+    });
+    return !endsWithIncomplete;
+}
+/**
+ * 检查代码块是否完整（基于代码内容）
+ * 用于流式输入时判断代码块是否已经完成
+ *
+ * @param code - 代码内容
+ * @param language - 代码语言（如 'mermaid', 'javascript' 等）
+ * @returns 是否可能完整
+ */ export function isCodeBlockLikelyComplete(code, language) {
+    var trimmed = code.trim();
+    if (!trimmed) return false;
+    // 对于 Mermaid，使用更严格的检查
+    if (language === 'mermaid') {
+        return isMermaidCodeComplete(trimmed);
+    }
+    // 对于其他语言，检查基本的完整性
+    // 如果代码很短，可能是正在输入中
+    if (trimmed.length < 5) return false;
+    // 检查是否以常见的不完整模式结尾
+    var incompletePatterns = [
+        /\\$/,
+        /\/\*[\s\S]*$/,
+        /\/\/.*$/,
+        /['"`][^'"`]*$/
+    ];
+    // 检查括号匹配
+    var hasUnclosedBrackets = checkUnclosedBrackets(trimmed);
+    if (hasUnclosedBrackets) return false;
+    // 如果匹配不完整模式，可能还在输入中
+    var endsWithIncomplete = incompletePatterns.some(function(pattern) {
+        return pattern.test(trimmed);
+    });
+    return !endsWithIncomplete;
+}
+export default findMatchingClose;

package/dist/MarkdownEditor/editor/utils/markdownToHtml.d.ts

@@ -1,6 +1,24 @@
 import type { Plugin } from 'unified';
 export type MarkdownRemarkPlugin = Plugin | [Plugin, ...unknown[]];
 export type MarkdownToHtmlOptions = MarkdownRemarkPlugin[];
+/**
+ * Markdown 转 HTML 的配置选项
+ */
+export interface MarkdownToHtmlConfig {
+    /** 是否在新标签页打开链接 */
+    openLinksInNewTab?: boolean;
+    /** 自定义段落标签，默认为 'p' */
+    paragraphTag?: string;
+    /** 用户自定义的 unified 插件配置 */
+    markedConfig?: MarkdownRemarkPlugin[];
+}
+/**
+ * HTML 转义函数
+ * @param html - 要转义的 HTML 字符串
+ * @param encode - 是否编码所有特殊字符（包括 &）
+ * @returns 转义后的字符串
+ */
+export declare function escapeHtml(html: string, encode?: boolean): string;
 export declare const DEFAULT_MARKDOWN_REMARK_PLUGINS: readonly MarkdownRemarkPlugin[];
 /**
  * 将 Markdown 内容转换为 HTML（异步版本）
@@ -11,19 +29,31 @@ export declare const DEFAULT_MARKDOWN_REMARK_PLUGINS: readonly MarkdownRemarkPlu
  * - 前置元数据 (Frontmatter)
  * - 特殊字符修复
  * - 原始 HTML 标签
+ * - 链接在新标签页打开（可选）
+ * - 自定义段落标签（可选）
+ * - 代码块流式状态支持
  *
  * @param markdown - 要转换的 Markdown 字符串
+ * @param plugins - 可选的 unified 插件配置
+ * @param config - 可选的渲染配置选项
  * @returns Promise<string> - 从 Markdown 生成的 HTML 字符串
  *
  * @example
  * ```typescript
  * const html = await markdownToHtml('# 标题\n\n这是**粗体**文本');
  * console.log(html); // '<h1>标题</h1><p>这是<strong>粗体</strong>文本</p>'
+ *
+ * // 使用配置选项
+ * const htmlWithConfig = await markdownToHtml(
+ *   '[链接](https://example.com)',
+ *   undefined,
+ *   { openLinksInNewTab: true, paragraphTag: 'div' }
+ * );
  * ```
  *
  * @throws {Error} 当转换过程中发生错误时返回空字符串
  */
-export declare const markdownToHtml: (markdown: string, plugins?: MarkdownToHtmlOptions) => Promise<string>;
+export declare const markdownToHtml: (markdown: string, plugins?: MarkdownToHtmlOptions, config?: MarkdownToHtmlConfig) => Promise<string>;
 /**
  * 将 Markdown 内容转换为 HTML（同步版本）
  *
@@ -31,12 +61,21 @@ export declare const markdownToHtml: (markdown: string, plugins?: MarkdownToHtml
  * 适用于不需要异步处理的场景，但可能会阻塞主线程。
  *
  * @param markdown - 要转换的 Markdown 字符串
+ * @param plugins - 可选的 unified 插件配置
+ * @param config - 可选的渲染配置选项
  * @returns string - 从 Markdown 生成的 HTML 字符串
  *
  * @example
  * ```typescript
  * const html = markdownToHtmlSync('## 副标题\n\n- 列表项1\n- 列表项2');
  * console.log(html); // '<h2>副标题</h2><ul><li>列表项1</li><li>列表项2</li></ul>'
+ *
+ * // 使用配置选项
+ * const htmlWithConfig = markdownToHtmlSync(
+ *   '[链接](https://example.com)',
+ *   undefined,
+ *   { openLinksInNewTab: true }
+ * );
  * ```
  *
  * @throws {Error} 当转换过程中发生错误时返回空字符串
@@ -45,4 +84,4 @@ export declare const markdownToHtml: (markdown: string, plugins?: MarkdownToHtml
  * - 建议在可能的情况下使用异步版本 `markdownToHtml`
  * - 同步版本可能影响用户界面响应性
  */
-export declare const markdownToHtmlSync: (markdown: string, plugins?: MarkdownToHtmlOptions) => string;
+export declare const markdownToHtmlSync: (markdown: string, plugins?: MarkdownToHtmlOptions, config?: MarkdownToHtmlConfig) => string;

package/dist/MarkdownEditor/editor/utils/markdownToHtml.js

@@ -165,7 +165,41 @@ import remarkMath from "remark-math";
 import remarkParse from "remark-parse";
 import remarkRehype from "remark-rehype";
 import { unified } from "unified";
+import { visit } from "unist-util-visit";
 import { fixStrongWithSpecialChars } from "../parser/remarkParse";
+// HTML 转义相关的正则表达式和工具
+var ESCAPE_TEST_NO_ENCODE = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/;
+var ESCAPE_TEST = /[&<>"']/;
+var ESCAPE_REPLACE = /[&<>"']/g;
+var ESCAPE_REPLACE_NO_ENCODE = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g;
+var ENDING_NEWLINE = /\n$/;
+var ESCAPE_REPLACEMENTS = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;'
+};
+var getEscapeReplacement = function(ch) {
+    return ESCAPE_REPLACEMENTS[ch];
+};
+/**
+ * HTML 转义函数
+ * @param html - 要转义的 HTML 字符串
+ * @param encode - 是否编码所有特殊字符（包括 &）
+ * @returns 转义后的字符串
+ */ export function escapeHtml(html, encode) {
+    if (encode) {
+        if (ESCAPE_TEST.test(html)) {
+            return html.replace(ESCAPE_REPLACE, getEscapeReplacement);
+        }
+    } else {
+        if (ESCAPE_TEST_NO_ENCODE.test(html)) {
+            return html.replace(ESCAPE_REPLACE_NO_ENCODE, getEscapeReplacement);
+        }
+    }
+    return html;
+}
 var INLINE_MATH_WITH_SINGLE_DOLLAR = {
     singleDollarTextMath: true
 };
@@ -173,6 +207,90 @@ var FRONTMATTER_LANGUAGES = [
     'yaml'
 ];
 var remarkRehypePlugin = remarkRehype;
+/**
+ * 配置链接渲染器，在新标签页打开链接
+ */ function rehypeLinkTarget() {
+    return function() {
+        return function(tree) {
+            visit(tree, 'element', function(node) {
+                if (node.tagName === 'a' && node.properties) {
+                    node.properties.target = '_blank';
+                    node.properties.rel = 'noopener noreferrer';
+                }
+            });
+        };
+    };
+}
+/**
+ * 配置段落渲染器，支持自定义段落标签
+ */ function rehypeParagraphTag() {
+    var tagName = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 'p';
+    return function() {
+        return function(tree) {
+            visit(tree, 'element', function(node) {
+                if (node.tagName === 'p') {
+                    node.tagName = tagName;
+                }
+            });
+        };
+    };
+}
+/**
+ * 从代码节点中提取原始文本
+ */ function getCodeText(node) {
+    if (!node.children) return '';
+    return node.children.map(function(child) {
+        if (child.type === 'text' && 'value' in child) {
+            return String(child.value);
+        }
+        if (child.type === 'element') {
+            return getCodeText(child);
+        }
+        return '';
+    }).join('');
+}
+/**
+ * 配置代码块渲染器，添加流式状态支持
+ */ function rehypeCodeBlock() {
+    return function() {
+        return function(tree) {
+            visit(tree, 'element', function(node) {
+                var _node_children;
+                if (node.tagName === 'pre' && ((_node_children = node.children) === null || _node_children === void 0 ? void 0 : _node_children[0])) {
+                    var codeNode = node.children[0];
+                    if (codeNode.tagName === 'code' && codeNode.properties) {
+                        // 检查是否为代码块（而非行内代码）
+                        // 代码块通常在 pre 标签内，且有 className 包含 language-
+                        var hasLanguageClass = codeNode.properties.className ? Array.isArray(codeNode.properties.className) ? codeNode.properties.className.some(function(cls) {
+                            return String(cls).startsWith('language-');
+                        }) : String(codeNode.properties.className).startsWith('language-') : false;
+                        // 或者通过检查代码内容长度来判断（代码块通常较长）
+                        var codeText = getCodeText(codeNode);
+                        var isBlock = hasLanguageClass || codeText.includes('\n') && codeText.length > 10;
+                        if (isBlock) {
+                            // 添加 data-block 属性
+                            codeNode.properties['data-block'] = 'true';
+                            // 默认设置为 done，在实际流式场景中可以通过外部传入状态
+                            // 这里我们检查代码是否看起来完整（有换行且不以换行结尾可能表示未完成）
+                            var endsWithNewline = codeText.match(ENDING_NEWLINE);
+                            var streamStatus = endsWithNewline ? 'done' : 'loading';
+                            // 添加 data-state 属性
+                            codeNode.properties['data-state'] = streamStatus;
+                            // 转义代码内容（移除末尾换行后重新添加，确保格式一致）
+                            if (codeNode.children && codeNode.children.length > 0) {
+                                var textNode = codeNode.children[0];
+                                if (textNode.type === 'text' && 'value' in textNode) {
+                                    var code = String(textNode.value).replace(ENDING_NEWLINE, '');
+                                    textNode.value = escapeHtml(code, true) + '\n';
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+        };
+    };
+}
 export var DEFAULT_MARKDOWN_REMARK_PLUGINS = [
     remarkParse,
     remarkGfm,
@@ -214,11 +332,24 @@ var resolveRemarkPlugins = function(plugins) {
     }
     return plugins;
 };
-var createMarkdownProcessor = function(plugins) {
+var createMarkdownProcessor = function(plugins, config) {
     var processor = unified();
     var remarkPlugins = resolveRemarkPlugins(plugins);
     applyPlugins(processor, remarkPlugins);
-    processor.use(rehypeRaw).use(rehypeKatex).use(rehypeStringify);
+    processor.use(rehypeRaw).use(rehypeKatex);
+    // 应用配置选项
+    if (config === null || config === void 0 ? void 0 : config.openLinksInNewTab) {
+        processor.use(rehypeLinkTarget());
+    }
+    if ((config === null || config === void 0 ? void 0 : config.paragraphTag) && config.paragraphTag !== 'p') {
+        processor.use(rehypeParagraphTag(config.paragraphTag));
+    }
+    processor.use(rehypeCodeBlock());
+    // 用户自定义配置（最后应用，可以覆盖默认配置）
+    if (config === null || config === void 0 ? void 0 : config.markedConfig) {
+        applyPlugins(processor, config.markedConfig);
+    }
+    processor.use(rehypeStringify);
     return processor;
 };
 /**
@@ -230,19 +361,31 @@ var createMarkdownProcessor = function(plugins) {
  * - 前置元数据 (Frontmatter)
  * - 特殊字符修复
  * - 原始 HTML 标签
+ * - 链接在新标签页打开（可选）
+ * - 自定义段落标签（可选）
+ * - 代码块流式状态支持
  *
  * @param markdown - 要转换的 Markdown 字符串
+ * @param plugins - 可选的 unified 插件配置
+ * @param config - 可选的渲染配置选项
  * @returns Promise<string> - 从 Markdown 生成的 HTML 字符串
  *
  * @example
  * ```typescript
  * const html = await markdownToHtml('# 标题\n\n这是**粗体**文本');
  * console.log(html); // '<h1>标题</h1><p>这是<strong>粗体</strong>文本</p>'
+ *
+ * // 使用配置选项
+ * const htmlWithConfig = await markdownToHtml(
+ *   '[链接](https://example.com)',
+ *   undefined,
+ *   { openLinksInNewTab: true, paragraphTag: 'div' }
+ * );
  * ```
  *
  * @throws {Error} 当转换过程中发生错误时返回空字符串
  */ export var markdownToHtml = /*#__PURE__*/ function() {
-    var _ref = _async_to_generator(function(markdown, plugins) {
+    var _ref = _async_to_generator(function(markdown, plugins, config) {
         var htmlContent, error;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
@@ -255,7 +398,7 @@ var createMarkdownProcessor = function(plugins) {
                     ]);
                     return [
                         4,
-                        createMarkdownProcessor(plugins).process(markdown)
+                        createMarkdownProcessor(plugins, config).process(markdown)
                     ];
                 case 1:
                     htmlContent = _state.sent();
@@ -277,7 +420,7 @@ var createMarkdownProcessor = function(plugins) {
             }
         });
     });
-    return function markdownToHtml(markdown, plugins) {
+    return function markdownToHtml(markdown, plugins, config) {
         return _ref.apply(this, arguments);
     };
 }();
@@ -288,12 +431,21 @@ var createMarkdownProcessor = function(plugins) {
  * 适用于不需要异步处理的场景，但可能会阻塞主线程。
  *
  * @param markdown - 要转换的 Markdown 字符串
+ * @param plugins - 可选的 unified 插件配置
+ * @param config - 可选的渲染配置选项
  * @returns string - 从 Markdown 生成的 HTML 字符串
  *
  * @example
  * ```typescript
  * const html = markdownToHtmlSync('## 副标题\n\n- 列表项1\n- 列表项2');
  * console.log(html); // '<h2>副标题</h2><ul><li>列表项1</li><li>列表项2</li></ul>'
+ *
+ * // 使用配置选项
+ * const htmlWithConfig = markdownToHtmlSync(
+ *   '[链接](https://example.com)',
+ *   undefined,
+ *   { openLinksInNewTab: true }
+ * );
  * ```
  *
  * @throws {Error} 当转换过程中发生错误时返回空字符串
@@ -301,9 +453,9 @@ var createMarkdownProcessor = function(plugins) {
  * @remarks
  * - 建议在可能的情况下使用异步版本 `markdownToHtml`
  * - 同步版本可能影响用户界面响应性
- */ export var markdownToHtmlSync = function(markdown, plugins) {
+ */ export var markdownToHtmlSync = function(markdown, plugins, config) {
     try {
-        var file = createMarkdownProcessor(plugins).processSync(markdown);
+        var file = createMarkdownProcessor(plugins, config).processSync(markdown);
         return String(file);
     } catch (error) {
         console.error('Error converting markdown to HTML:', error);

package/dist/Plugins/chart/AreaChart/index.d.ts

@@ -2,6 +2,16 @@ import React from 'react';
 import { ChartContainerProps } from '../components';
 import { StatisticConfigType } from '../hooks/useChartStatistic';
 import { ChartDataItem } from '../utils';
+/**
+ * @fileoverview 面积图组件文件
+ *
+ * 该文件提供了面积图组件的实现，基于 Chart.js 和 react-chartjs-2。
+ * 支持数据可视化、交互、配置、统计等功能。
+ *
+ * @author md-editor
+ * @version 1.0.0
+ * @since 2024
+ */
 /**
  * 面积图数据项类型
  *
@@ -129,6 +139,8 @@ export interface AreaChartProps extends ChartContainerProps {
     renderFilterInToolbar?: boolean;
     /** ChartStatistic组件配置：object表示单个配置，array表示多个配置 */
     statistic?: StatisticConfigType;
+    /** 是否显示加载状态（当图表未闭合时显示） */
+    loading?: boolean;
 }
 /**
  * 面积图组件