@matechat/ng 0.0.1-alpha.0 → 20.0.1-alpha.0

package/esm2022/components-common/MarkdownCard/common/parser.mjs

@@ -0,0 +1,194 @@
+// 判断是否自闭合标签
+export const isSelfClosingTag = (token) => {
+    // 判断token.content里面是否包含完整的HTML结构（所有开始标签都有对应的结束标签）
+    const content = token.content || '';
+    // 检查是否是自闭合标签（如 <img />, <br /> 等）
+    if (content.match(/<(\w+)[^>]*\/>/)) {
+        return true;
+    }
+    // 检查是否包含完整的HTML结构
+    const tagStack = [];
+    const openTagRegex = /<(\w+)[^>]*>/g;
+    const closeTagRegex = /<\/(\w+)>/g;
+    let openMatch;
+    let closeMatch;
+    // 重置正则表达式的lastIndex
+    openTagRegex.lastIndex = 0;
+    closeTagRegex.lastIndex = 0;
+    // 按顺序处理所有标签
+    const allMatches = [];
+    // 收集所有开始标签
+    while ((openMatch = openTagRegex.exec(content)) !== null) {
+        allMatches.push({
+            type: 'open',
+            tagName: openMatch[1],
+            index: openMatch.index
+        });
+    }
+    // 收集所有结束标签
+    while ((closeMatch = closeTagRegex.exec(content)) !== null) {
+        allMatches.push({
+            type: 'close',
+            tagName: closeMatch[1],
+            index: closeMatch.index
+        });
+    }
+    // 按位置排序
+    allMatches.sort((a, b) => a.index - b.index);
+    // 检查标签是否完全匹配
+    for (const match of allMatches) {
+        if (match.type === 'open') {
+            tagStack.push(match.tagName);
+        }
+        else {
+            if (tagStack.length === 0) {
+                return false; // 没有对应的开始标签
+            }
+            const lastOpenTag = tagStack[tagStack.length - 1];
+            if (lastOpenTag !== match.tagName) {
+                return false; // 标签不匹配
+            }
+            tagStack.pop();
+        }
+    }
+    // 只有当所有标签都正确匹配时，才认为是自闭合的
+    return tagStack.length === 0;
+};
+// 判断是否是结束标签
+export const isClosingTag = (openToken, closeToken) => {
+    const openContent = openToken?.content || '';
+    const closeContent = closeToken?.content || '';
+    const openTagMatch = openContent.match(/<(\w+)/);
+    const closeTagMatch = closeContent.match(/<\/(\w+)/);
+    if (openTagMatch && closeTagMatch) {
+        return openTagMatch[1] === closeTagMatch[1];
+    }
+    return false;
+};
+// 创建ast树节点
+export const genTreeNode = (node) => {
+    return {
+        nodeType: node ? node.type.replace('_open', '') : 'root',
+        openNode: node,
+        closeNode: null,
+        children: [],
+        vNodeKey: node?.vNodeKey || ''
+    };
+};
+// 匹配成对html token
+export const matchHtmlToken = (token, stack) => {
+    // 简单排除单独的闭合标签
+    const isCloseTag = token.content.startsWith('</');
+    if (!stack.length) {
+        token.nesting = isCloseTag ? 0 : 1;
+        stack.push(token);
+        return;
+    }
+    // 判断当前token是否是上一个html token的闭合标签
+    const prevToken = stack[stack.length - 1];
+    const closing = isClosingTag(prevToken, token);
+    if (closing) {
+        token.nesting = -1;
+        stack.pop();
+    }
+    else {
+        if (isCloseTag) {
+            token.nesting = 0;
+        }
+        else {
+            token.nesting = 1;
+            stack.push(token);
+        }
+    }
+};
+export const isValidTagName = (tagName) => {
+    if (!tagName)
+        return false;
+    try {
+        document.createElement(tagName);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};
+export const tokensToAst = (tokens) => {
+    // 递归处理 inline 类型的 token
+    const processInlineToken = (token) => {
+        const node = genTreeNode(token);
+        // 如果 token 有 children，递归处理它们
+        if (token.children && token.children.length > 0) {
+            node.children = tokensToAst(token.children);
+        }
+        return node;
+    };
+    // 创建根节点
+    const rootNode = genTreeNode(null);
+    let curr = rootNode;
+    const stack = [];
+    const htmlInlineTokenStack = [];
+    const htmlBlockTokenStack = [];
+    // 处理html token nesting值
+    tokens.forEach((tok, idx) => {
+        tok.vNodeKey = `mc-markdown-content-key-${idx}`;
+        tok.tokenIndex = idx;
+        if (tok.type.includes('html_')) {
+            if (isSelfClosingTag(tok)) {
+                tok.nesting = 0;
+                return;
+            }
+            const stack = tok.type === 'html_block'
+                ? htmlBlockTokenStack
+                : htmlInlineTokenStack;
+            matchHtmlToken(tok, stack);
+        }
+    });
+    tokens.forEach((tok, idx) => {
+        let tmp;
+        if (tok.nesting === 1) {
+            // 开始标签
+            tmp = genTreeNode(tok);
+            curr.children.push(tmp);
+            stack.push(curr);
+            curr = tmp;
+        }
+        else if (tok.nesting === -1) {
+            // 结束标签
+            curr.closeNode = tok;
+            if (!stack.length) {
+                throw new Error('AST stack underflow.');
+            }
+            tmp = stack.pop();
+            curr = tmp;
+        }
+        else if (tok.nesting === 0) {
+            // 自闭合标签或 inline 内容
+            if (tok.type === 'inline' && tok.children && tok.children.length > 0) {
+                // 对于 inline 类型，递归处理其 children
+                const inlineNode = processInlineToken(tok);
+                curr.children.push(inlineNode);
+            }
+            else {
+                // 普通 token，直接添加
+                curr.children.push(tok);
+            }
+        }
+        else {
+            throw new Error(`Invalid nesting level found in token index ${idx}.`);
+        }
+    });
+    if (stack.length !== 0) {
+        // throw new Error('Unbalanced block open/close tokens.');
+    }
+    return rootNode.children;
+};
+// 声明一个utils静态默认导出
+export default {
+    isSelfClosingTag,
+    isClosingTag,
+    tokensToAst,
+    genTreeNode,
+    matchHtmlToken,
+    isValidTagName
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parser.js","sourceRoot":"","sources":["../../../../../../projects/components-ng/src/components-common/MarkdownCard/common/parser.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Token } from \"markdown-it\";\nimport type { ASTNode } from './mdCard.types';\n// 判断是否自闭合标签\nexport const isSelfClosingTag = (token: Token): boolean => {\n    // 判断token.content里面是否包含完整的HTML结构（所有开始标签都有对应的结束标签）\n    const content = token.content || '';\n\n    // 检查是否是自闭合标签（如 <img />, <br /> 等）\n    if (content.match(/<(\\w+)[^>]*\\/>/)) {\n        return true;\n    }\n\n    // 检查是否包含完整的HTML结构\n    const tagStack: string[] = [];\n    const openTagRegex = /<(\\w+)[^>]*>/g;\n    const closeTagRegex = /<\\/(\\w+)>/g;\n\n    let openMatch;\n    let closeMatch;\n\n    // 重置正则表达式的lastIndex\n    openTagRegex.lastIndex = 0;\n    closeTagRegex.lastIndex = 0;\n\n    // 按顺序处理所有标签\n    const allMatches: Array<{ type: 'open' | 'close', tagName: string, index: number }> = [];\n\n    // 收集所有开始标签\n    while ((openMatch = openTagRegex.exec(content)) !== null) {\n        allMatches.push({\n            type: 'open',\n            tagName: openMatch[1],\n            index: openMatch.index\n        });\n    }\n\n    // 收集所有结束标签\n    while ((closeMatch = closeTagRegex.exec(content)) !== null) {\n        allMatches.push({\n            type: 'close',\n            tagName: closeMatch[1],\n            index: closeMatch.index\n        });\n    }\n\n    // 按位置排序\n    allMatches.sort((a, b) => a.index - b.index);\n\n    // 检查标签是否完全匹配\n    for (const match of allMatches) {\n        if (match.type === 'open') {\n            tagStack.push(match.tagName);\n        } else {\n            if (tagStack.length === 0) {\n                return false; // 没有对应的开始标签\n            }\n            const lastOpenTag = tagStack[tagStack.length - 1];\n            if (lastOpenTag !== match.tagName) {\n                return false; // 标签不匹配\n            }\n            tagStack.pop();\n        }\n    }\n\n    // 只有当所有标签都正确匹配时，才认为是自闭合的\n    return tagStack.length === 0;\n}\n\n// 判断是否是结束标签\nexport const isClosingTag = (openToken: Token, closeToken: Token): boolean => {\n    const openContent = openToken?.content || '';\n    const closeContent = closeToken?.content || '';\n\n    const openTagMatch = openContent.match(/<(\\w+)/);\n    const closeTagMatch = closeContent.match(/<\\/(\\w+)/);\n\n    if (openTagMatch && closeTagMatch) {\n        return openTagMatch[1] === closeTagMatch[1];\n    }\n\n    return false;\n}\n\n// 创建ast树节点\nexport const genTreeNode = (node: Token | null): ASTNode => {\n    return {\n        nodeType: node ? node.type.replace('_open', '') : 'root',\n        openNode: node,\n        closeNode: null,\n        children: [],\n        vNodeKey: (node as any)?.vNodeKey || ''\n    };\n};\n\n// 匹配成对html token\nexport const matchHtmlToken = (token: Token, stack: Token[]) => {\n    // 简单排除单独的闭合标签\n    const isCloseTag = token.content.startsWith('</');\n    if (!stack.length) {\n        token.nesting = isCloseTag ? 0 : 1;\n        stack.push(token);\n        return;\n    }\n    // 判断当前token是否是上一个html token的闭合标签\n    const prevToken = stack[stack.length - 1];\n    const closing = isClosingTag(prevToken, token);\n    if (closing) {\n        token.nesting = -1;\n        stack.pop();\n    } else {\n        if (isCloseTag) {\n            token.nesting = 0;\n        } else {\n            token.nesting = 1;\n            stack.push(token);\n        }\n    }\n}\n\nexport const isValidTagName = (tagName: string | undefined): boolean => {\n    if (!tagName) return false\n    try {\n        document.createElement(tagName)\n        return true\n    } catch (error) {\n        return false\n    }\n}\n\nexport const tokensToAst = (tokens: Token[]) => {\n    // 递归处理 inline 类型的 token\n    const processInlineToken = (token: Token): ASTNode => {\n      const node = genTreeNode(token);\n\n      // 如果 token 有 children，递归处理它们\n      if (token.children && token.children.length > 0) {\n        node.children = tokensToAst(token.children);\n      }\n\n      return node;\n    };\n\n    // 创建根节点\n    const rootNode = genTreeNode(null);\n    let curr: ASTNode = rootNode;\n    const stack: ASTNode[] = [];\n    const htmlInlineTokenStack: Token[] = [];\n    const htmlBlockTokenStack: Token[] = [];\n    // 处理html token nesting值\n    tokens.forEach((tok: Token, idx: number) => {\n      (tok as any).vNodeKey = `mc-markdown-content-key-${idx}`;\n      (tok as any).tokenIndex = idx;\n\n      if (tok.type.includes('html_')) {\n        if (isSelfClosingTag(tok)) {\n          tok.nesting = 0;\n          return;\n        }\n\n        const stack =\n          tok.type === 'html_block'\n            ? htmlBlockTokenStack\n            : htmlInlineTokenStack;\n\n        matchHtmlToken(tok, stack);\n      }\n    });\n\n    tokens.forEach((tok: Token, idx: number) => {\n      let tmp: ASTNode;\n      if (tok.nesting === 1) {\n        // 开始标签\n        tmp = genTreeNode(tok);\n        curr.children.push(tmp);\n        stack.push(curr);\n        curr = tmp;\n      } else if (tok.nesting === -1) {\n        // 结束标签\n        curr.closeNode = tok;\n        if (!stack.length) {\n          throw new Error('AST stack underflow.');\n        }\n        tmp = stack.pop()!;\n        curr = tmp;\n      } else if (tok.nesting === 0) {\n        // 自闭合标签或 inline 内容\n        if (tok.type === 'inline' && tok.children && tok.children.length > 0) {\n          // 对于 inline 类型，递归处理其 children\n          const inlineNode = processInlineToken(tok);\n          curr.children.push(inlineNode);\n        } else {\n          // 普通 token，直接添加\n          curr.children.push(tok);\n        }\n      } else {\n        throw new Error(`Invalid nesting level found in token index ${idx}.`);\n      }\n    });\n\n    if (stack.length !== 0) {\n      // throw new Error('Unbalanced block open/close tokens.');\n    }\n    return rootNode.children as ASTNode[];\n  };\n\n// 声明一个utils静态默认导出\nexport default {\n    isSelfClosingTag,\n    isClosingTag,\n    tokensToAst,\n    genTreeNode,\n    matchHtmlToken,\n    isValidTagName\n}"]}

package/esm2022/components-common/MarkdownCard/foundation.mjs

@@ -0,0 +1,84 @@
+import BaseFoundation from '../Base/foundation';
+import { defaultTypingConfig } from './common/mdCard.types';
+export class MarkdownCardFoundation extends BaseFoundation {
+    constructor(adapter) {
+        super({ ...adapter });
+        this.isToken = (node) => {
+            return 'type' in node && 'content' in node;
+        };
+        this.typewriterEnd = () => {
+            this.setState({ isTyping: false });
+            this._adapter.typingEnd?.();
+        };
+        this.getThinkContent = (content, thinkOptions) => {
+            const thinkClass = thinkOptions?.customClass || 'mc-think-block';
+            return (content
+                ?.replace('<think>', `<div class="${thinkClass}">`)
+                ?.replace('</think>', '</div>') || '');
+        };
+        this.parseTypingContent = (content) => {
+            const { typingOptions } = this.getProps();
+            const { typingIndex } = this.getStates();
+            content = content.slice(0, typingIndex) || '';
+            const options = { ...defaultTypingConfig, ...typingOptions };
+            if (options.style === 'cursor') {
+                content += `<span class="mc-typewriter mc-typewriter-cursor">|</span>`;
+            }
+            else if (options.style === 'color' || options.style === 'gradient') {
+                content =
+                    content.slice(0, -5) +
+                        `<span class="mc-typewriter mc-typewriter-${options.style}">${content.slice(-5)}</span>`;
+            }
+            return content || '';
+        };
+        this.parseContent = () => {
+            const { content, thinkOptions, enableThink } = this.getProps();
+            const { typing, isTyping } = this.getStates();
+            let parseContent = content || '';
+            if (typing && isTyping) {
+                parseContent = this.parseTypingContent(content);
+            }
+            if (enableThink) {
+                parseContent = this.getThinkContent(content, thinkOptions);
+            }
+            parseContent = this._adapter.parseContent(parseContent);
+        };
+        this.typewriterStart = () => {
+            const { typingOptions } = this.getProps();
+            const { timer } = this.getStates();
+            if (timer) {
+                clearTimeout(timer);
+            }
+            this.setState({ isTyping: true });
+            this._adapter.typingStart?.();
+            const options = { ...defaultTypingConfig, ...typingOptions };
+            const typingStep = () => {
+                const { typingIndex, content } = this.getStates();
+                let step = options.step || 2;
+                if (Array.isArray(options.step)) {
+                    step =
+                        options.step[0] +
+                            Math.floor(Math.random() * (options.step[1] - options.step[0]));
+                }
+                let index = typingIndex + step;
+                this.setState({ typingIndex: index });
+                this.parseContent();
+                this._adapter.typingEvent();
+                if (index >= content.length) {
+                    this.typewriterEnd();
+                    this.parseContent();
+                    return;
+                }
+                let typingTimeout = setTimeout(typingStep, typeof options.interval === 'number' ? options.interval : 50);
+                this.setState({
+                    timer: typingTimeout,
+                });
+            };
+            let typingStepTimeout = setTimeout(typingStep);
+            this.setState({
+                timer: typingStepTimeout,
+            });
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"foundation.js","sourceRoot":"","sources":["../../../../../projects/components-ng/src/components-common/MarkdownCard/foundation.ts"],"names":[],"mappings":"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","sourcesContent":["import BaseFoundation, { DefaultAdapter } from '../Base/foundation';\nimport type { Token } from 'markdown-it';\nimport type { ASTNode } from './common/mdCard.types';\nimport { defaultTypingConfig } from './common/mdCard.types';\n\nexport interface MarkdownCardAdapter extends DefaultAdapter {\n  locale(key: string, params?: Record<string, string>): string;\n  typingStart: () => void;\n  typingEnd: () => void;\n  typingEvent: () => void;\n  parseContent: (content: string) => void;\n}\n\nexport class MarkdownCardFoundation extends BaseFoundation<MarkdownCardAdapter> {\n  constructor(adapter: MarkdownCardAdapter) {\n    super({ ...adapter });\n  }\n\n  isToken = (node: ASTNode | Token): node is Token => {\n    return 'type' in node && 'content' in node;\n  };\n\n  typewriterEnd = () => {\n    this.setState({ isTyping: false });\n    this._adapter.typingEnd?.();\n  };\n\n  getThinkContent = (content: string, thinkOptions: any) => {\n    const thinkClass = thinkOptions?.customClass || 'mc-think-block';\n    return (\n      content\n        ?.replace('<think>', `<div class=\"${thinkClass}\">`)\n        ?.replace('</think>', '</div>') || ''\n    );\n  };\n\n  parseTypingContent = (content: string) => {\n    const { typingOptions } = this.getProps();\n    const { typingIndex } = this.getStates();\n    content = content.slice(0, typingIndex) || '';\n    const options = { ...defaultTypingConfig, ...typingOptions };\n\n    if (options.style === 'cursor') {\n      content += `<span class=\"mc-typewriter mc-typewriter-cursor\">|</span>`;\n    } else if (options.style === 'color' || options.style === 'gradient') {\n      content =\n        content.slice(0, -5) +\n        `<span class=\"mc-typewriter mc-typewriter-${\n          options.style\n        }\">${content.slice(-5)}</span>`;\n    }\n    return content || '';\n  };\n\n  parseContent = () => {\n    const { content, thinkOptions, enableThink } = this.getProps();\n    const { typing, isTyping } = this.getStates();\n    let parseContent = content || '';\n    if (typing && isTyping) {\n      parseContent = this.parseTypingContent(content);\n    }\n\n    if (enableThink) {\n      parseContent = this.getThinkContent(content, thinkOptions);\n    }\n\n    parseContent = this._adapter.parseContent(parseContent);\n  };\n\n  typewriterStart = () => {\n    const { typingOptions } = this.getProps();\n    const { timer } = this.getStates();\n    if (timer) {\n      clearTimeout(timer);\n    }\n\n    this.setState({ isTyping: true });\n    this._adapter.typingStart?.();\n    const options = { ...defaultTypingConfig, ...typingOptions };\n\n    const typingStep = () => {\n      const { typingIndex, content } = this.getStates();\n\n      let step = options.step || 2;\n      if (Array.isArray(options.step)) {\n        step =\n          options.step[0] +\n          Math.floor(Math.random() * (options.step[1] - options.step[0]));\n      }\n      let index = typingIndex + step;\n      this.setState({ typingIndex: index });\n      this.parseContent();\n      this._adapter.typingEvent();\n\n      if (index >= content!.length) {\n        this.typewriterEnd();\n        this.parseContent();\n        return;\n      }\n\n      let typingTimeout = setTimeout(\n        typingStep,\n        typeof options.interval === 'number' ? options.interval : 50\n      );\n      this.setState({\n        timer: typingTimeout,\n      });\n    };\n\n    let typingStepTimeout = setTimeout(typingStep);\n    this.setState({\n      timer: typingStepTimeout,\n    });\n  };\n}\n"]}

package/esm2022/public-api.mjs

@@ -4,4 +4,5 @@
 export * from './Bubble/index';
 export * from './Input/index';
 export * from './Locale/index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMtbmcvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGNvbXBvbmVudHMtbmdcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL0J1YmJsZS9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL0lucHV0L2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vTG9jYWxlL2luZGV4JztcbiJdfQ==
+export * from './MarkdownCard/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMtbmcvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgY29tcG9uZW50cy1uZ1xuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vQnViYmxlL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vSW5wdXQvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9Mb2NhbGUvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9NYXJrZG93bkNhcmQvaW5kZXgnO1xuIl19