@ant-design/agentic-ui 2.20.2 → 2.22.0

package/dist/MarkdownEditor/editor/parser/parse/parseCode.d.ts

@@ -0,0 +1,32 @@
+export type CodeElement = {
+    type: string;
+    language?: string | null;
+    render?: boolean;
+    value: any;
+    isConfig?: boolean;
+    children: Array<{
+        text: string;
+    }>;
+    otherProps?: Record<string, any>;
+};
+export type LanguageHandler = (element: CodeElement, value: string) => CodeElement;
+/**
+ * 处理代码块节点
+ * @param currentElement - 当前处理的代码块元素，包含语言和内容
+ * @returns 返回格式化的代码块节点对象，根据语言类型进行特殊处理
+ */
+export declare const handleCode: (currentElement: any) => CodeElement;
+/**
+ * 处理YAML节点
+ * @param currentElement - 当前处理的YAML元素
+ * @returns 返回格式化的YAML代码块节点对象
+ */
+export declare const handleYaml: (currentElement: any) => {
+    type: string;
+    language: string;
+    value: any;
+    frontmatter: boolean;
+    children: {
+        text: any;
+    }[];
+};

package/dist/MarkdownEditor/editor/parser/parse/parseCode.js

@@ -0,0 +1,186 @@
+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 _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;
+}
+import json5 from "json5";
+import { isCodeBlockLikelyComplete } from "../../utils/findMatchingClose";
+import partialJsonParse from "../json-parse";
+// 代码块检测相关的常量
+var NOT_SPACE_START = /^\S*/;
+var ENDING_NEWLINE = /\n$/;
+/**
+ * 处理schema类型语言的辅助函数
+ */ var processSchemaLanguage = function(element, value) {
+    var json = [];
+    try {
+        json = json5.parse(value || '[]');
+    } catch (e) {
+        try {
+            json = partialJsonParse(value || '[]');
+        } catch (error) {
+            json = value;
+            console.error('parse schema error', error);
+        }
+    }
+    return _object_spread_props(_object_spread({}, element), {
+        type: 'apaasify',
+        value: json,
+        children: [
+            {
+                text: value
+            }
+        ]
+    });
+};
+/**
+ * 语言类型处理策略配置
+ */ var LANGUAGE_HANDLERS = {
+    mermaid: function(element) {
+        return _object_spread_props(_object_spread({}, element), {
+            type: 'mermaid'
+        });
+    },
+    schema: processSchemaLanguage,
+    apaasify: processSchemaLanguage,
+    apassify: processSchemaLanguage,
+    katex: function(element) {
+        return _object_spread_props(_object_spread({}, element), {
+            type: 'katex'
+        });
+    },
+    'agentar-card': processSchemaLanguage
+};
+/**
+ * 处理代码块节点
+ * @param currentElement - 当前处理的代码块元素，包含语言和内容
+ * @returns 返回格式化的代码块节点对象，根据语言类型进行特殊处理
+ */ export var handleCode = function(currentElement) {
+    var _match, _currentElement_otherProps, _currentElement_value_trim;
+    var rawValue = currentElement.value || '';
+    var langString = ((_match = (currentElement.lang || '').match(NOT_SPACE_START)) === null || _match === void 0 ? void 0 : _match[0]) || '';
+    var code = "".concat(rawValue.replace(ENDING_NEWLINE, ''), "\n");
+    // 检查代码块是否完整
+    // 如果是缩进代码块，认为是完整的（因为没有结束标记）
+    var isIndentedCode = currentElement.meta === 'indented';
+    // 使用更智能的方法判断代码块是否完整
+    var streamStatus = 'loading';
+    if (isIndentedCode) {
+        // 缩进代码块没有结束标记，认为是完整的
+        streamStatus = 'done';
+    } else {
+        // 对于围栏代码块，使用多种方法判断
+        var endsWithNewline = code.match(ENDING_NEWLINE);
+        // 如果代码以换行结尾，可能是完整的
+        if (endsWithNewline) {
+            // 进一步检查代码内容是否完整（特别是对于 Mermaid 等需要完整语法的情况）
+            var isLikelyComplete = isCodeBlockLikelyComplete(rawValue, currentElement.lang);
+            streamStatus = isLikelyComplete ? 'done' : 'loading';
+        } else {
+            // 没有换行结尾，肯定不完整
+            streamStatus = 'loading';
+        }
+    }
+    // 如果已经在 parseNodes 中设置了 finished（基于是否是最后一个节点），优先使用它
+    // 否则使用 streamStatus 判断
+    var finishValue = ((_currentElement_otherProps = currentElement.otherProps) === null || _currentElement_otherProps === void 0 ? void 0 : _currentElement_otherProps.finished) !== undefined ? currentElement.otherProps.finished : streamStatus === 'done';
+    var otherProps = _object_spread(_object_spread_props(_object_spread({}, currentElement.otherProps || {}), {
+        'data-block': 'true',
+        'data-state': streamStatus,
+        // 优先使用 parseNodes 中设置的 finish，否则使用 streamStatus 判断
+        finished: finishValue
+    }), langString ? {
+        'data-language': langString
+    } : {});
+    if (finishValue !== false) {
+        delete otherProps.finished;
+    }
+    var baseCodeElement = {
+        type: 'code',
+        language: currentElement.lang === 'apaasify' ? 'apaasify' : currentElement.lang,
+        render: currentElement.meta === 'render',
+        value: currentElement.value,
+        isConfig: currentElement === null || currentElement === void 0 ? void 0 : (_currentElement_value_trim = currentElement.value.trim()) === null || _currentElement_value_trim === void 0 ? void 0 : _currentElement_value_trim.startsWith('<!--'),
+        children: [
+            {
+                text: currentElement.value
+            }
+        ],
+        // 添加流式状态支持
+        otherProps: otherProps
+    };
+    var handler = LANGUAGE_HANDLERS[currentElement.lang];
+    var result = handler ? handler(baseCodeElement, currentElement.value) : baseCodeElement;
+    // 确保 otherProps 被保留
+    var resultWithProps = result;
+    if (baseCodeElement.otherProps && !resultWithProps.otherProps) {
+        resultWithProps.otherProps = baseCodeElement.otherProps;
+    } else if (baseCodeElement.otherProps && resultWithProps.otherProps) {
+        resultWithProps.otherProps = _object_spread({}, resultWithProps.otherProps, baseCodeElement.otherProps);
+    }
+    return resultWithProps;
+};
+/**
+ * 处理YAML节点
+ * @param currentElement - 当前处理的YAML元素
+ * @returns 返回格式化的YAML代码块节点对象
+ */ export var handleYaml = function(currentElement) {
+    return {
+        type: 'code',
+        language: 'yaml',
+        value: currentElement.value,
+        frontmatter: true,
+        children: [
+            {
+                text: currentElement.value
+            }
+        ]
+    };
+};

package/dist/MarkdownEditor/editor/parser/parse/parseElements.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 处理内联代码节点
+ * @param currentElement - 当前处理的内联代码元素
+ * @returns 返回格式化的内联代码节点对象，支持占位符和初始值
+ */
+export declare const handleInlineCode: (currentElement: any) => any;
+/**
+ * 处理分割线节点
+ * @returns 返回格式化的分割线节点对象
+ */
+export declare const handleThematicBreak: () => {
+    type: string;
+    children: {
+        text: string;
+    }[];
+};
+/**
+ * 处理定义节点
+ * @param currentElement - 当前处理的定义元素，包含标签和URL
+ * @returns 返回格式化的定义段落节点对象
+ */
+export declare const handleDefinition: (currentElement: any) => {
+    type: string;
+    children: {
+        text: string;
+    }[];
+};

package/dist/MarkdownEditor/editor/parser/parse/parseElements.js

@@ -0,0 +1,83 @@
+/**
+ * 处理内联代码节点
+ * @param currentElement - 当前处理的内联代码元素
+ * @returns 返回格式化的内联代码节点对象，支持占位符和初始值
+ */ export var handleInlineCode = function(currentElement) {
+    var _currentElement_value, _currentElement_value1;
+    var hasPlaceHolder = (_currentElement_value = currentElement.value) === null || _currentElement_value === void 0 ? void 0 : _currentElement_value.match(/\$\{(.*?)\}/);
+    var values = undefined;
+    if (hasPlaceHolder) {
+        // 使用逗号分割多个键值对，例如：placeholder:目标场景,initialValue:已选择
+        var content = hasPlaceHolder[1];
+        values = {};
+        // 匹配 key:value 格式，支持逗号分隔
+        var keyValuePattern = /(\w+):([^,]+)/g;
+        var match;
+        while((match = keyValuePattern.exec(content)) !== null){
+            var key = match[1];
+            var value = match[2];
+            if (key && value !== undefined && value !== null) {
+                values[key] = value;
+            }
+        }
+    }
+    var isTag = (_currentElement_value1 = currentElement.value) === null || _currentElement_value1 === void 0 ? void 0 : _currentElement_value1.startsWith('${');
+    var result = {
+        code: true,
+        tag: isTag ? true : false
+    };
+    // 优先使用 initialValue，其次使用 placeholder，最后使用原始值
+    if (values === null || values === void 0 ? void 0 : values.initialValue) {
+        result.text = values.initialValue || ' ';
+    }
+    if (!result.text && (values === null || values === void 0 ? void 0 : values.placeholder)) {
+        // 当有 placeholder 时，text 设置为空格，避免空字符串导致 tag 被移除
+        result.text = ' ';
+    }
+    if (!result.text) {
+        // 只有当不是 ${ 开头的占位符时，才使用原始值
+        if (!isTag) {
+            result.text = currentElement.value;
+        } else {
+            // 如果是 ${ 开头但没有匹配到值，使用空格避免空字符串
+            result.text = ' ';
+        }
+    }
+    // 设置 placeholder 和 initialValue
+    // 如果是 tag 且值存在，设置实际值；否则设置为 undefined（符合测试期望）
+    if (isTag) {
+        result.placeholder = values === null || values === void 0 ? void 0 : values.placeholder;
+        result.initialValue = values === null || values === void 0 ? void 0 : values.initialValue;
+    } else {
+        result.placeholder = undefined;
+        result.initialValue = undefined;
+    }
+    return result;
+};
+/**
+ * 处理分割线节点
+ * @returns 返回格式化的分割线节点对象
+ */ export var handleThematicBreak = function() {
+    return {
+        type: 'hr',
+        children: [
+            {
+                text: ''
+            }
+        ]
+    };
+};
+/**
+ * 处理定义节点
+ * @param currentElement - 当前处理的定义元素，包含标签和URL
+ * @returns 返回格式化的定义段落节点对象
+ */ export var handleDefinition = function(currentElement) {
+    return {
+        type: 'paragraph',
+        children: [
+            {
+                text: "[".concat(currentElement.label, "]: ") + (currentElement.url ? "".concat(currentElement.url) : '')
+            }
+        ]
+    };
+};

package/dist/MarkdownEditor/editor/parser/parse/parseEmptyLines.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 根据行间距添加空行元素（纯函数版本）
+ * @param els - 目标元素数组
+ * @param preNode - 前一个节点
+ * @param currentElement - 当前处理的元素
+ * @param top - 是否为顶级解析
+ * @returns 返回添加了空行元素的新数组
+ */
+export declare const addEmptyLinesIfNeeded: (els: any[], preNode: any, currentElement: any, top: boolean) => any[];

package/dist/MarkdownEditor/editor/parser/parse/parseEmptyLines.js

@@ -0,0 +1,60 @@
+// 常量定义
+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_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+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 _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);
+}
+var EMPTY_LINE_DISTANCE_THRESHOLD = 4; // 两个元素之间的行距阈值
+var EMPTY_LINE_CALCULATION_OFFSET = 2; // 计算空行数量时的偏移量
+var EMPTY_LINE_DIVISOR = 2; // 计算空行数量的除数
+/**
+ * 根据行间距添加空行元素（纯函数版本）
+ * @param els - 目标元素数组
+ * @param preNode - 前一个节点
+ * @param currentElement - 当前处理的元素
+ * @param top - 是否为顶级解析
+ * @returns 返回添加了空行元素的新数组
+ */ export var addEmptyLinesIfNeeded = function(els, preNode, currentElement, top) {
+    var _currentElement_position, _preNode_position;
+    if (!preNode || !top) {
+        return els;
+    }
+    var distance = (((_currentElement_position = currentElement.position) === null || _currentElement_position === void 0 ? void 0 : _currentElement_position.start.line) || 0) - (((_preNode_position = preNode.position) === null || _preNode_position === void 0 ? void 0 : _preNode_position.end.line) || 0);
+    if (distance < EMPTY_LINE_DISTANCE_THRESHOLD) {
+        return els;
+    }
+    var lines = Math.floor((distance - EMPTY_LINE_CALCULATION_OFFSET) / EMPTY_LINE_DIVISOR);
+    var emptyLines = Array.from({
+        length: lines
+    }, function() {
+        return {
+            type: 'paragraph',
+            children: [
+                {
+                    text: ''
+                }
+            ]
+        };
+    });
+    return _to_consumable_array(els).concat(_to_consumable_array(emptyLines));
+};

package/dist/MarkdownEditor/editor/parser/parse/parseFootnote.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 处理脚注引用
+ * @param currentElement - 当前处理的脚注引用元素
+ * @returns 返回格式化的脚注引用节点对象
+ */
+export declare const handleFootnoteReference: (currentElement: any) => {
+    text: string;
+    identifier: any;
+    type: string;
+};

package/dist/MarkdownEditor/editor/parser/parse/parseFootnote.js

@@ -0,0 +1,12 @@
+/**
+ * 处理脚注引用
+ * @param currentElement - 当前处理的脚注引用元素
+ * @returns 返回格式化的脚注引用节点对象
+ */ export var handleFootnoteReference = function(currentElement) {
+    var _currentElement_identifier;
+    return {
+        text: "".concat((_currentElement_identifier = currentElement.identifier) === null || _currentElement_identifier === void 0 ? void 0 : _currentElement_identifier.toUpperCase()),
+        identifier: currentElement.identifier,
+        type: 'footnoteReference'
+    };
+};

package/dist/MarkdownEditor/editor/parser/parse/parseHtml.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 解码 URI 组件，处理错误情况
+ */
+export declare const decodeURIComponentUrl: (url: string) => string;
+/**
+ * 查找并解析媒体元素（img/video/iframe）
+ */
+export declare const findImageElement: (str: string) => any;
+/**
+ * 根据媒体元素信息创建编辑器节点
+ */
+export declare const createMediaNodeFromElement: (mediaElement: ReturnType<typeof findImageElement>) => import("../../../..").CardNode | {
+    text: string;
+} | null;
+/**
+ * 标准 HTML 元素列表
+ * 这些标签会被正常解析为 HTML，其他标签会被当作普通文本处理
+ */
+export declare const STANDARD_HTML_ELEMENTS: Set<string>;
+/**
+ * 检查 HTML 标签是否为标准元素
+ * @param htmlString - HTML 字符串
+ * @returns 是否为标准 HTML 元素
+ */
+export declare function isStandardHtmlElement(htmlString: string): boolean;
+/**
+ * 查找附件链接
+ */
+export declare const findAttachment: (str: string) => {
+    url: string;
+    size: number;
+} | null;
+/**
+ * 处理HTML节点
+ * @param currentElement - 当前处理的HTML元素
+ * @param parent - 父级元素，用于判断上下文
+ * @param htmlTag - HTML标签栈，用于跟踪嵌套的HTML标签
+ * @returns 返回包含解析后元素和上下文属性的对象
+ */
+export declare const handleHtml: (currentElement: any, parent: any, htmlTag: any[]) => {
+    el: any;
+    contextProps: any;
+    htmlTag: any[];
+};
+/**
+ * 预处理特殊标签（think/answer），将其转换为代码块格式
+ * @param markdown - 原始 Markdown 字符串
+ * @param tagName - 标签名称（think 或 answer）
+ * @returns 处理后的 Markdown 字符串
+ */
+export declare function preprocessSpecialTags(markdown: string, tagName: 'think' | 'answer'): string;
+/**
+ * 预处理 <think> 标签，将其转换为 ```think 代码块格式
+ * @param markdown - 原始 Markdown 字符串
+ * @returns 处理后的 Markdown 字符串
+ */
+export declare function preprocessThinkTags(markdown: string): string;
+/**
+ * 预处理所有非标准 HTML 标签，提取其内容（删除标签本身）
+ * @param markdown - 原始 Markdown 字符串
+ * @returns 处理后的 Markdown 字符串
+ */
+export declare function preprocessNonStandardHtmlTags(markdown: string): string;