@appthen/cli 1.2.2 → 1.2.3

package/dist/TSXComplianceChecker.js

@@ -1,683 +0,0 @@
-"use strict";
-/**
- * TSX 规范检查器 - 共享版本
- * 用于检查 TSX 文件是否符合平台特定的语法规范
- * 注意：此文件与 packages/cli/src/services/TSXComplianceChecker.ts 保持同步
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TSXComplianceChecker = void 0;
-class TSXComplianceChecker {
-    /**
-     * 检查 TSX 文件内容是否符合规范
-     */
-    static checkTSXCompliance(content, filePath) {
-        const issues = [];
-        const suggestions = [];
-        // 检查是否是 TSX 文件
-        if (filePath && !filePath.endsWith('.tsx')) {
-            return { isCompliant: true, issues: [], suggestions: [] };
-        }
-        // 1. 检查文件结构完整性
-        this.checkFileStructure(content, issues, suggestions);
-        // 2. 检查 render() 方法约束
-        this.checkRenderMethod(content, issues, suggestions);
-        // 3. 检查类方法中的 TypeScript 语法
-        this.checkMethodTypeScript(content, issues, suggestions);
-        // 4. 检查类方法中的 JSX 语法
-        this.checkMethodJSX(content, issues, suggestions);
-        // 5. 检查对象安全访问
-        this.checkObjectAccess(content, issues, suggestions);
-        // 6. 检查回调函数中的变量声明
-        this.checkCallbackVariableDeclarations(content, issues, suggestions);
-        const isCompliant = issues.filter((issue) => issue.type === 'error').length === 0;
-        return {
-            isCompliant,
-            issues,
-            suggestions,
-        };
-    }
-    /**
-     * 检查文件结构完整性
-     */
-    static checkFileStructure(content, issues, suggestions) {
-        // 检查 JSDoc 元数据注释
-        if (!content.includes('@type Page') &&
-            !content.includes('@type Component')) {
-            issues.push({
-                type: 'error',
-                code: 'MISSING_METADATA',
-                message: '缺少必需的 JSDoc 元数据注释 (@type Page|Component)',
-                suggestion: '在文件顶部添加: /**\n * 组件标题\n * @type Page|Component\n */',
-            });
-        }
-        // 检查 IProps 类
-        if (!content.includes('class IProps')) {
-            issues.push({
-                type: 'error',
-                code: 'MISSING_IPROPS',
-                message: '缺少 IProps 类定义',
-                suggestion: '添加: class IProps { /* 属性定义 */ }',
-            });
-        }
-        // 检查 IState 类
-        if (!content.includes('class IState')) {
-            issues.push({
-                type: 'error',
-                code: 'MISSING_ISTATE',
-                message: '缺少 IState 类定义',
-                suggestion: '添加: class IState { /* 状态定义 */ }',
-            });
-        }
-        // 检查 Document 类
-        if (!content.includes('class Document extends React.Component')) {
-            issues.push({
-                type: 'error',
-                code: 'MISSING_DOCUMENT_CLASS',
-                message: '缺少 Document 类定义',
-                suggestion: '添加: class Document extends React.Component<IProps, IState> { /* 组件实现 */ }',
-            });
-        }
-        // 检查 export default
-        if (!content.includes('export default Document')) {
-            issues.push({
-                type: 'error',
-                code: 'MISSING_EXPORT',
-                message: '缺少 export default Document',
-                suggestion: '在文件末尾添加: export default Document;',
-            });
-        }
-    }
-    /**
-     * 检查 render() 方法约束 - 使用 AST 方式
-     */
-    static checkRenderMethod(content, issues, suggestions) {
-        // 先找到 class Document 部分
-        const documentCodeIndex = content.search(/class\s+(\w+)\s+extends\s+React\.Component/);
-        if (documentCodeIndex === -1) {
-            issues.push({
-                type: 'error',
-                code: 'MISSING_DOCUMENT_CLASS',
-                message: '缺少 Document 类定义',
-                suggestion: '添加: class Document extends React.Component<IProps, IState> { /* 组件实现 */ }',
-            });
-            return;
-        }
-        // 只处理 class Document 部分，避免解析非常规的 IProps/IState 语法
-        const documentCode = content.slice(documentCodeIndex);
-        try {
-            // 使用 AST 检查 render() 方法
-            this.checkRenderMethodWithAST(documentCode, issues, suggestions);
-        }
-        catch (error) {
-            // 如果 AST 解析失败，回退到原来的正则表达式方法
-            console.warn('AST 解析失败，回退到正则表达式方法:', error);
-            this.checkRenderMethodWithRegex(content, issues, suggestions);
-        }
-    }
-    /**
-     * 使用 AST 检查 render() 方法
-     */
-    static checkRenderMethodWithAST(documentCode, issues, suggestions) {
-        // 这里先用简化的方法，后续可以集成真正的 AST 解析
-        // 目前先实现基本的逻辑，确保不会破坏现有功能
-        this.checkRenderMethodWithRegex(documentCode, issues, suggestions);
-    }
-    /**
-     * 使用正则表达式检查 render() 方法（回退方法）
-     */
-    static checkRenderMethodWithRegex(content, issues, suggestions) {
-        // 更精确的 render 方法匹配
-        const renderBody = this.extractRenderMethodBody(content);
-        if (!renderBody) {
-            issues.push({
-                type: 'error',
-                code: 'MISSING_RENDER_METHOD',
-                message: '缺少 render() 方法',
-                suggestion: '添加: render() { return (<div>内容</div>); }',
-            });
-            return;
-        }
-        // 检查变量声明（排除事件处理函数内部，但包含.map()回调）
-        const renderBodyWithoutEventHandlers = this.removeEventHandlers(renderBody);
-        const varDeclMatch = renderBodyWithoutEventHandlers.match(/\b(const|let|var)\s+\w+/);
-        if (varDeclMatch) {
-            // 如果在处理后的内容中仍然找到变量声明，说明这个变量声明不在事件处理函数中
-            // 现在需要在原始内容中找到对应的位置来报告错误
-            const varPattern = varDeclMatch[0];
-            const processedMatchIndex = renderBodyWithoutEventHandlers.indexOf(varPattern);
-            // 在原始renderBody中找到相同的变量声明模式
-            const originalMatchIndex = renderBody.indexOf(varPattern);
-            if (originalMatchIndex !== -1) {
-                // 检查这个变量声明是否在.map()回调中
-                const isInMapCallback = this.isVariableInMapCallback(renderBody, originalMatchIndex);
-                if (isInMapCallback) {
-                    // 这个错误会在checkCallbackVariableDeclarations中处理
-                    return;
-                }
-                // 报告错误
-                const renderStartIndex = content.indexOf(renderBody);
-                const absoluteIndex = renderStartIndex + originalMatchIndex;
-                const lineNumber = this.getLineNumber(content, absoluteIndex);
-                const { snippet, startLine, endLine } = this.extractCodeSnippet(content, lineNumber);
-                issues.push({
-                    type: 'error',
-                    code: 'RENDER_VARIABLE_DECLARATION',
-                    message: 'render() 方法中不能包含变量声明',
-                    suggestion: '移除所有 const/let/var 声明，直接使用 this.state.xxx',
-                    line: lineNumber,
-                    codeSnippet: snippet,
-                    snippetStartLine: startLine,
-                    snippetEndLine: endLine,
-                });
-            }
-        }
-        // 检查解构赋值（在移除事件处理函数后的内容中检查）
-        const destructMatch = renderBodyWithoutEventHandlers.match(/\b(const|let|var)\s*\{/);
-        if (destructMatch) {
-            // 在原始renderBody中找到对应的解构赋值
-            const originalDestructMatch = renderBody.match(/\b(const|let|var)\s*\{/);
-            if (originalDestructMatch) {
-                const matchIndex = renderBody.indexOf(originalDestructMatch[0]);
-                const renderStartIndex = content.indexOf(renderBody);
-                const absoluteIndex = renderStartIndex + matchIndex;
-                const lineNumber = this.getLineNumber(content, absoluteIndex);
-                const { snippet, startLine, endLine } = this.extractCodeSnippet(content, lineNumber);
-                issues.push({
-                    type: 'error',
-                    code: 'RENDER_DESTRUCTURING',
-                    message: 'render() 方法中不能包含解构赋值',
-                    suggestion: '使用 this.state.xxx 直接访问，而不是解构',
-                    line: lineNumber,
-                    codeSnippet: snippet,
-                    snippetStartLine: startLine,
-                    snippetEndLine: endLine,
-                });
-            }
-        }
-        // 检查逻辑语句（排除事件处理函数内部）
-        if (/\b(if|for|while|switch)\s*\(/.test(renderBodyWithoutEventHandlers)) {
-            issues.push({
-                type: 'error',
-                code: 'RENDER_LOGIC_STATEMENTS',
-                message: 'render() 方法中不能包含 if/for/while/switch 等逻辑语句',
-                suggestion: '使用条件渲染: {!!(condition) && <JSX>}',
-            });
-        }
-        // 检查 return 是否在第一行
-        const firstLine = renderBody.trim().split('\n')[0];
-        if (!firstLine.includes('return')) {
-            issues.push({
-                type: 'error',
-                code: 'RENDER_RETURN_NOT_FIRST',
-                message: 'render() 方法第一行必须是 return (',
-                suggestion: '确保 render() 方法第一行是: return (',
-            });
-        }
-        // 三元表达式检查已移除 - 代码转换器会自动处理
-    }
-    /**
-     * 提取 render 方法体
-     */
-    static extractRenderMethodBody(content) {
-        // 查找 render() 方法的开始位置
-        const renderMatch = content.match(/render\s*\(\s*\)\s*\{/);
-        if (!renderMatch) {
-            return null;
-        }
-        const startIndex = renderMatch.index + renderMatch[0].length;
-        let braceCount = 1;
-        let endIndex = startIndex;
-        // 找到匹配的闭合大括号
-        for (let i = startIndex; i < content.length && braceCount > 0; i++) {
-            const char = content[i];
-            if (char === '{') {
-                braceCount++;
-            }
-            else if (char === '}') {
-                braceCount--;
-            }
-            endIndex = i;
-        }
-        if (braceCount !== 0) {
-            return null; // 大括号不匹配
-        }
-        return content.substring(startIndex, endIndex);
-    }
-    /**
-     * 提取代码片段，用于错误展示
-     */
-    static extractCodeSnippet(content, targetLine, contextLines = 3) {
-        const lines = content.split('\n');
-        const startLine = Math.max(1, targetLine - contextLines);
-        const endLine = Math.min(lines.length, targetLine + contextLines);
-        const snippetLines = lines.slice(startLine - 1, endLine);
-        const snippet = snippetLines
-            .map((line, index) => {
-            const lineNumber = startLine + index;
-            const marker = lineNumber === targetLine ? '>>> ' : '    ';
-            return `${marker}${lineNumber.toString().padStart(3)}: ${line}`;
-        })
-            .join('\n');
-        return { snippet, startLine, endLine };
-    }
-    /**
-     * 根据正则匹配结果获取行号
-     */
-    static getLineNumber(content, matchIndex) {
-        const beforeMatch = content.substring(0, matchIndex);
-        return (beforeMatch.match(/\n/g) || []).length + 1;
-    }
-    /**
-     * 检查变量声明是否在.map()回调函数中
-     */
-    static isVariableInMapCallback(renderBody, varIndex) {
-        // 查找所有.map()回调函数的位置
-        const mapRegex = /\.map\s*\(\s*\([^)]*\)\s*=>\s*\{/g;
-        let match;
-        while ((match = mapRegex.exec(renderBody)) !== null) {
-            const callbackStart = match.index + match[0].length;
-            // 找到对应的结束大括号
-            let braceCount = 1;
-            let callbackEnd = callbackStart;
-            for (let i = callbackStart; i < renderBody.length && braceCount > 0; i++) {
-                if (renderBody[i] === '{')
-                    braceCount++;
-                if (renderBody[i] === '}')
-                    braceCount--;
-                callbackEnd = i;
-            }
-            // 检查变量声明是否在这个回调函数范围内
-            if (varIndex >= callbackStart && varIndex <= callbackEnd) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * 移除事件处理函数内容，但保留.map()等数组方法回调
-     */
-    static removeEventHandlers(renderBody) {
-        let result = renderBody;
-        // 注意：不移除.map()等数组方法回调，因为需要单独检查它们
-        // 移除事件处理函数（但保留.map()等数组方法）
-        const lines = result.split('\n');
-        const processedLines = [];
-        let inEventHandler = false;
-        let braceCount = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            // 检查事件处理函数和其他非JSX返回的回调函数
-            const eventHandlerMatch = line.match(/on\w+\s*=\s*\{/) || // onXxx={
-                line.match(/on\w+\s*=\s*\([^)]*\)\s*=>\s*\{/) || // onXxx={(params) => {
-                line.match(/on\w+\s*=\s*\{\s*\([^)]*\)\s*=>\s*\{/) || // onXxx={ (params) => {
-                line.match(/on\w+\s*=\s*\{\s*function\s*\([^)]*\)\s*\{/) || // onXxx={ function() {
-                line.match(/on\w+\s*=\s*function\s*\([^)]*\)\s*\{/) ||
-                // 添加其他非JSX返回的回调函数
-                line.match(/request\s*=\s*\{/) ||
-                line.match(/request\s*=\s*\([^)]*\)\s*=>\s*\{/) ||
-                line.match(/request\s*=\s*\{\s*\([^)]*\)\s*=>\s*\{/) ||
-                line.match(/request\s*=\s*\{\s*async\s*\([^)]*\)\s*=>\s*\{/) ||
-                line.match(/request\s*=\s*async\s*\([^)]*\)\s*=>\s*\{/) ||
-                // 添加addEventListener等事件监听器
-                line.match(/addEventListener\s*\(\s*['"][^'"]*['"]\s*,\s*\([^)]*\)\s*=>\s*\{/) ||
-                line.match(/addEventListener\s*\(\s*['"][^'"]*['"]\s*,\s*function\s*\([^)]*\)\s*\{/) ||
-                line.match(/addEventListener\s*\(\s*['"][^'"]*['"]\s*,\s*\{/) ||
-                // 添加其他常见的回调函数模式
-                line.match(/\.\w+\s*\(\s*\([^)]*\)\s*=>\s*\{/) || // .method((params) => {
-                line.match(/\.\w+\s*\(\s*function\s*\([^)]*\)\s*\{/); // .method(function(params) {
-            if (eventHandlerMatch) {
-                inEventHandler = true;
-                braceCount = 0;
-                // 计算这一行的大括号
-                for (const char of line) {
-                    if (char === '{')
-                        braceCount++;
-                    if (char === '}')
-                        braceCount--;
-                }
-                if (braceCount <= 0) {
-                    // 单行事件处理函数
-                    processedLines.push(line.replace(/on\w+\s*=\s*\{[^}]*\}/, 'onEvent={() => {}}'));
-                    inEventHandler = false;
-                }
-                else {
-                    // 多行事件处理函数开始
-                    processedLines.push(line.replace(/on\w+\s*=\s*\{.*/, 'onEvent={() => {'));
-                }
-                continue;
-            }
-            if (inEventHandler) {
-                // 在事件处理函数内部，计算大括号
-                for (const char of line) {
-                    if (char === '{')
-                        braceCount++;
-                    if (char === '}')
-                        braceCount--;
-                }
-                if (braceCount <= 0) {
-                    // 事件处理函数结束
-                    processedLines.push('}}');
-                    inEventHandler = false;
-                }
-                else {
-                    // 仍在事件处理函数内部，跳过这一行（移除变量声明）
-                    processedLines.push('// event handler content removed');
-                }
-            }
-            else {
-                // 正常行，保持不变（包括.map()等数组方法）
-                processedLines.push(line);
-            }
-        }
-        return processedLines.join('\n');
-    }
-    /**
-     * 检查类方法中的 TypeScript 语法
-     */
-    static checkMethodTypeScript(content, issues, suggestions) {
-        // 检查方法参数类型注解（更精确的匹配）
-        // 只匹配真正的类方法，不匹配函数调用或其他语法
-        const methodParamTypeRegex = /^\s*(\w+)\s*\([^)]*:\s*[^)]+\)\s*\{/gm;
-        let match;
-        while ((match = methodParamTypeRegex.exec(content)) !== null) {
-            const methodName = match[1];
-            // 跳过一些常见的非方法名称
-            const skipNames = ['if', 'for', 'while', 'switch', 'catch', 'function'];
-            if (skipNames.includes(methodName))
-                continue;
-            if (methodName !== 'render') {
-                const lineNumber = this.getLineNumber(content, match.index);
-                const { snippet, startLine, endLine } = this.extractCodeSnippet(content, lineNumber);
-                issues.push({
-                    type: 'error',
-                    code: 'METHOD_PARAM_TYPE_ANNOTATION',
-                    message: `方法 ${methodName} 不能包含参数类型注解`,
-                    suggestion: `将 ${methodName}(param: Type) 改为 ${methodName}(param)`,
-                    line: lineNumber,
-                    codeSnippet: snippet,
-                    snippetStartLine: startLine,
-                    snippetEndLine: endLine,
-                });
-            }
-        }
-        // 检查方法返回类型注解（只检查类方法，不检查数组方法调用）
-        const methodReturnTypeRegex = /^\s*(\w+)\s*\([^)]*\)\s*:\s*\w+/gm;
-        while ((match = methodReturnTypeRegex.exec(content)) !== null) {
-            const methodName = match[1];
-            // 排除数组方法调用（如 .filter, .map 等）和常见的非方法名称
-            const skipNames = [
-                'filter',
-                'map',
-                'forEach',
-                'reduce',
-                'find',
-                'some',
-                'every',
-                'if',
-                'for',
-                'while',
-                'switch',
-                'catch',
-                'function',
-            ];
-            if (!skipNames.includes(methodName)) {
-                const lineNumber = this.getLineNumber(content, match.index);
-                const { snippet, startLine, endLine } = this.extractCodeSnippet(content, lineNumber);
-                issues.push({
-                    type: 'error',
-                    code: 'METHOD_RETURN_TYPE_ANNOTATION',
-                    message: `方法 ${methodName} 不能包含返回类型注解`,
-                    suggestion: `将 ${methodName}(): Type 改为 ${methodName}()`,
-                    line: lineNumber,
-                    codeSnippet: snippet,
-                    snippetStartLine: startLine,
-                    snippetEndLine: endLine,
-                });
-            }
-        }
-        // 检查类型断言
-        if (/\w+\s+as\s+\w+/.test(content)) {
-            issues.push({
-                type: 'error',
-                code: 'TYPE_ASSERTION',
-                message: '不能使用类型断言 (as)',
-                suggestion: '直接使用变量，移除 as 断言',
-            });
-        }
-        // 检查泛型语法（除了 React.Component<IProps, IState>）
-        // 更精确的泛型匹配，避免匹配JSX标签
-        const genericRegex = /\b(\w+)<([^<>]+)>/g;
-        while ((match = genericRegex.exec(content)) !== null) {
-            const fullMatch = match[0];
-            const typeName = match[1];
-            const typeParams = match[2];
-            // 跳过JSX标签（JSX标签通常以大写字母开头，且在<>内包含属性或文本）
-            // 检查是否是JSX标签的结束部分（如 "detected</div>"）
-            if (typeParams.includes('/') ||
-                typeParams.includes(' ') ||
-                /^[A-Z]/.test(typeName)) {
-                continue;
-            }
-            // 允许的泛型语法
-            const allowedGenerics = [
-                'React.Component<IProps, IState>',
-                'React.PureComponent<IProps, IState>',
-                'Component<IProps, IState>',
-                'PureComponent<IProps, IState>',
-            ];
-            const isAllowed = allowedGenerics.some((allowed) => fullMatch.includes(allowed) || content.includes(`extends ${allowed}`));
-            if (!isAllowed) {
-                const lineNumber = this.getLineNumber(content, match.index);
-                const { snippet, startLine, endLine } = this.extractCodeSnippet(content, lineNumber);
-                issues.push({
-                    type: 'error',
-                    code: 'GENERIC_SYNTAX',
-                    message: `不能使用泛型语法: ${fullMatch}`,
-                    suggestion: '使用基础类型，如 any[] 代替 Array<T>。注意：React.Component<IProps, IState> 是允许的',
-                    line: lineNumber,
-                    codeSnippet: snippet,
-                    snippetStartLine: startLine,
-                    snippetEndLine: endLine,
-                });
-            }
-        }
-    }
-    /**
-     * 检查类方法中的 JSX 语法
-     */
-    static checkMethodJSX(content, issues, suggestions) {
-        // 更精确的方法匹配正则表达式，只匹配真正的类方法
-        // 匹配类方法：methodName(params) { ... }
-        const classMethodRegex = /^\s*(\w+)\s*\([^)]*\)\s*\{([\s\S]*?)\n\s*\}/gm;
-        const checkMethod = (methodName, methodBody, matchIndex) => {
-            // 跳过 render 方法和一些常见的渲染相关方法
-            const renderMethods = [
-                'render',
-                'renderItem',
-                'renderContent',
-                'renderHeader',
-                'renderFooter',
-            ];
-            if (renderMethods.includes(methodName))
-                return;
-            // 检查方法中是否包含 JSX（更精确的检查）
-            // 匹配真正的JSX标签，而不是比较操作符
-            const jsxRegex = /<[A-Z][a-zA-Z0-9]*[\s\S]*?>/;
-            if (jsxRegex.test(methodBody)) {
-                const lineNumber = this.getLineNumber(content, matchIndex);
-                const { snippet, startLine, endLine } = this.extractCodeSnippet(content, lineNumber);
-                issues.push({
-                    type: 'error',
-                    code: 'METHOD_CONTAINS_JSX',
-                    message: `方法 ${methodName} 不能包含 JSX 语法`,
-                    suggestion: '只有 render() 方法可以包含 JSX，其他方法只处理逻辑',
-                    line: lineNumber,
-                    codeSnippet: snippet,
-                    snippetStartLine: startLine,
-                    snippetEndLine: endLine,
-                });
-            }
-        };
-        // 检查类方法
-        let match;
-        while ((match = classMethodRegex.exec(content)) !== null) {
-            checkMethod(match[1], match[2], match.index);
-        }
-        // 检查箭头函数属性中的 JSX（更精确的检查）
-        const arrowFunctionRegex = /^\s*(\w+)\s*=\s*\([^)]*\)\s*=>\s*([\s\S]*?)(?=\n\s*\w+\s*[=:]|\n\s*\}|\n\s*$)/gm;
-        while ((match = arrowFunctionRegex.exec(content)) !== null) {
-            const propName = match[1];
-            const functionBody = match[2];
-            // 检查是否包含JSX
-            const jsxRegex = /<[A-Z][a-zA-Z0-9]*[\s\S]*?>/;
-            if (jsxRegex.test(functionBody)) {
-                const lineNumber = this.getLineNumber(content, match.index);
-                const { snippet, startLine, endLine } = this.extractCodeSnippet(content, lineNumber);
-                issues.push({
-                    type: 'error',
-                    code: 'PROPERTY_CONTAINS_JSX',
-                    message: `属性 ${propName} 不能包含 JSX 语法`,
-                    suggestion: '移除属性中的 JSX，只在 render() 方法中使用 JSX',
-                    line: lineNumber,
-                    codeSnippet: snippet,
-                    snippetStartLine: startLine,
-                    snippetEndLine: endLine,
-                });
-            }
-        }
-    }
-    /**
-     * 检查对象安全访问
-     */
-    static checkObjectAccess(content, issues, suggestions) {
-        // 提取 state 初始化信息
-        const stateInitMatch = content.match(/state\s*=\s*\{([\s\S]*?)\}/);
-        const initializedProperties = new Set();
-        if (stateInitMatch) {
-            const stateInit = stateInitMatch[1];
-            // 匹配已初始化的属性（有默认值的）
-            const propertyMatches = stateInit.matchAll(/(\w+):\s*([^,\n}]+)/g);
-            for (const propMatch of propertyMatches) {
-                const propName = propMatch[1];
-                const propValue = propMatch[2].trim();
-                // 如果有非空默认值，认为是安全的
-                if (propValue !== 'null' &&
-                    propValue !== 'undefined' &&
-                    propValue !== '' &&
-                    propValue !== "''") {
-                    initializedProperties.add(propName);
-                }
-            }
-        }
-        // 检查嵌套对象访问是否使用可选链
-        const unsafeAccessRegex = /this\.state\.(\w+)\.(\w+)/g;
-        let match;
-        while ((match = unsafeAccessRegex.exec(content)) !== null) {
-            const objectName = match[1];
-            const propertyName = match[2];
-            // 如果属性已经初始化为非空值，跳过检查
-            if (initializedProperties.has(objectName)) {
-                continue;
-            }
-            // 检查是否已经使用了可选链
-            const fullMatch = match[0];
-            const beforeMatch = content.substring(0, match.index);
-            if (!beforeMatch.endsWith('?.') && !fullMatch.includes('?.')) {
-                issues.push({
-                    type: 'warning',
-                    code: 'UNSAFE_OBJECT_ACCESS',
-                    message: `不安全的对象访问: ${fullMatch}`,
-                    suggestion: `使用可选链: this.state.${objectName}?.${propertyName}`,
-                });
-            }
-        }
-    }
-    /**
-     * 生成检查报告
-     */
-    static generateReport(result, filePath) {
-        const { isCompliant, issues, suggestions } = result;
-        let report = `\n=== TSX 规范检查报告 ===\n`;
-        if (filePath) {
-            report += `文件: ${filePath}\n`;
-        }
-        if (isCompliant) {
-            report += `✅ 检查通过：文件符合 TSX 规范\n`;
-        }
-        else {
-            report += `❌ 检查失败：发现 ${issues.filter((i) => i.type === 'error').length} 个错误\n`;
-        }
-        if (issues.length > 0) {
-            report += `\n--- 问题详情 ---\n`;
-            issues.forEach((issue, index) => {
-                const icon = issue.type === 'error' ? '❌' : '⚠️';
-                report += `${index + 1}. ${icon} [${issue.code}] ${issue.message}\n`;
-                if (issue.line) {
-                    report += `   📍 位置: 第 ${issue.line} 行\n`;
-                }
-                if (issue.suggestion) {
-                    report += `   💡 建议: ${issue.suggestion}\n`;
-                }
-                if (issue.codeSnippet) {
-                    report += `   📝 代码片段:\n${issue.codeSnippet}\n`;
-                }
-            });
-        }
-        if (suggestions.length > 0) {
-            report += `\n--- 改进建议 ---\n`;
-            suggestions.forEach((suggestion, index) => {
-                report += `${index + 1}. ${suggestion}\n`;
-            });
-        }
-        return report;
-    }
-    /**
-     * 检查返回JSX的回调函数中的变量声明
-     */
-    static checkCallbackVariableDeclarations(content, issues, suggestions) {
-        // 先提取render方法体
-        const renderBody = this.extractRenderMethodBody(content);
-        if (!renderBody) {
-            return; // 没有render方法，跳过检查
-        }
-        // 检查所有数组方法的回调函数，但只针对返回JSX的情况
-        const arrayMethodRegex = /\.(map|filter|forEach|reduce|find|some|every)\s*\(\s*\([^)]*\)\s*=>\s*\{([\s\S]*?)\}\s*\)/g;
-        let match;
-        while ((match = arrayMethodRegex.exec(renderBody)) !== null) {
-            const methodName = match[1];
-            const callbackBody = match[2];
-            // 检查回调函数是否返回JSX（包含return <xxx>或直接返回JSX）
-            const returnsJSX = /return\s*</.test(callbackBody) || // return <div>
-                /return\s*\(\s*</.test(callbackBody) || // return (<div>
-                /=>\s*</.test(match[0]) || // () => <div>
-                /=>\s*\(\s*</.test(match[0]); // () => (<div>
-            if (!returnsJSX) {
-                continue; // 不返回JSX，跳过检查
-            }
-            // 检查回调函数体中是否有变量声明
-            const variableDeclarationRegex = /^\s*(const|let|var)\s+\w+/gm;
-            let varMatch;
-            while ((varMatch = variableDeclarationRegex.exec(callbackBody)) !== null) {
-                const declarationType = varMatch[1];
-                // 计算在整个文件中的行号
-                const renderStartIndex = content.indexOf(renderBody);
-                const callbackStartIndex = renderStartIndex + match.index + match[0].indexOf('{') + 1;
-                const varMatchIndex = callbackStartIndex + varMatch.index;
-                const beforeMatch = content.substring(0, varMatchIndex);
-                const lineNumber = (beforeMatch.match(/\n/g) || []).length + 1;
-                const { snippet, startLine, endLine } = this.extractCodeSnippet(content, lineNumber);
-                issues.push({
-                    type: 'error',
-                    code: 'JSX_CALLBACK_VARIABLE_DECLARATION',
-                    message: `返回JSX的 .${methodName}() 回调函数中不能声明变量 (${declarationType})`,
-                    line: lineNumber,
-                    suggestion: '使用内联表达式，或将逻辑移到其他方法中处理数据',
-                    codeSnippet: snippet,
-                    snippetStartLine: startLine,
-                    snippetEndLine: endLine,
-                });
-            }
-        }
-    }
-}
-exports.TSXComplianceChecker = TSXComplianceChecker;