react-code-smell-detector 1.2.0 → 1.4.1

package/dist/cli.js

@@ -6,24 +6,37 @@ import path from 'path';
 import { analyzeProject, DEFAULT_CONFIG } from './analyzer.js';
 import { reportResults } from './reporter.js';
 import { generateHTMLReport } from './htmlReporter.js';
+import { fixFile, isFixable } from './fixer.js';
+import { startWatch } from './watcher.js';
+import { getAllModifiedFiles, filterReactFiles, getGitInfo } from './git.js';
+import { initializeBaseline, recordBaseline, formatTrendReport } from './baseline.js';
+import { sendWebhookNotification, getWebhookConfig } from './webhooks.js';
 import fs from 'fs/promises';
 const program = new Command();
 program
     .name('react-smell')
     .description('Detect code smells in React projects')
-    .version('1.2.0')
+    .version('1.3.0')
     .argument('[directory]', 'Directory to analyze', '.')
     .option('-f, --format <format>', 'Output format: console, json, markdown, html', 'console')
     .option('-s, --snippets', 'Show code snippets in output', false)
     .option('-c, --config <file>', 'Path to config file')
     .option('--ci', 'CI mode: exit with code 1 if any issues found')
     .option('--fail-on <severity>', 'Exit with code 1 if issues of this severity or higher (error, warning, info)', 'error')
+    .option('--fix', 'Auto-fix simple issues (console.log, var, ==, missing alt)')
+    .option('--watch', 'Watch mode: re-analyze on file changes')
+    .option('--changed', 'Only analyze git-modified files')
     .option('--max-effects <number>', 'Max useEffects per component', parseInt)
     .option('--max-props <number>', 'Max props before warning', parseInt)
     .option('--max-lines <number>', 'Max lines per component', parseInt)
     .option('--include <patterns>', 'Glob patterns to include (comma-separated)')
     .option('--exclude <patterns>', 'Glob patterns to exclude (comma-separated)')
     .option('-o, --output <file>', 'Write output to file')
+    .option('--baseline', 'Enable baseline tracking and trend analysis', false)
+    .option('--slack <url>', 'Slack webhook URL for notifications')
+    .option('--discord <url>', 'Discord webhook URL for notifications')
+    .option('--webhook <url>', 'Generic webhook URL for notifications')
+    .option('--webhook-threshold <number>', 'Only notify if smells exceed this threshold', parseInt)
     .action(async (directory, options) => {
     const rootDir = path.resolve(process.cwd(), directory);
     // Check if directory exists
@@ -34,38 +47,103 @@ program
         console.error(chalk.red(`Error: Directory "${rootDir}" does not exist.`));
         process.exit(1);
     }
-    const spinner = ora('Analyzing React project...').start();
-    try {
-        // Load config file if specified
-        let fileConfig = {};
-        if (options.config) {
-            try {
-                const configPath = path.resolve(process.cwd(), options.config);
-                const configContent = await fs.readFile(configPath, 'utf-8');
-                fileConfig = JSON.parse(configContent);
-            }
-            catch (error) {
-                spinner.fail(`Could not load config file: ${error.message}`);
-                process.exit(1);
-            }
+    // Load config file if specified
+    let fileConfig = {};
+    if (options.config) {
+        try {
+            const configPath = path.resolve(process.cwd(), options.config);
+            const configContent = await fs.readFile(configPath, 'utf-8');
+            fileConfig = JSON.parse(configContent);
         }
-        // Build config from options
-        const config = {
-            ...DEFAULT_CONFIG,
-            ...fileConfig,
-            ...(options.maxEffects && { maxUseEffectsPerComponent: options.maxEffects }),
-            ...(options.maxProps && { maxPropsCount: options.maxProps }),
-            ...(options.maxLines && { maxComponentLines: options.maxLines }),
-        };
-        const include = options.include?.split(',').map((p) => p.trim()) || undefined;
-        const exclude = options.exclude?.split(',').map((p) => p.trim()) || undefined;
-        const result = await analyzeProject({
+        catch (error) {
+            console.error(chalk.red(`Could not load config file: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    // Build config from options
+    const config = {
+        ...DEFAULT_CONFIG,
+        ...fileConfig,
+        ...(options.maxEffects && { maxUseEffectsPerComponent: options.maxEffects }),
+        ...(options.maxProps && { maxPropsCount: options.maxProps }),
+        ...(options.maxLines && { maxComponentLines: options.maxLines }),
+    };
+    const include = options.include?.split(',').map((p) => p.trim()) || ['**/*.tsx', '**/*.jsx'];
+    const exclude = options.exclude?.split(',').map((p) => p.trim()) || ['**/node_modules/**', '**/dist/**'];
+    // Watch mode
+    if (options.watch) {
+        const watcher = startWatch({
             rootDir,
             include,
             exclude,
             config,
+            showSnippets: options.snippets,
+        });
+        // Handle Ctrl+C gracefully
+        process.on('SIGINT', () => {
+            watcher.close();
+            process.exit(0);
+        });
+        return; // Don't continue to regular analysis
+    }
+    // Git changed files mode
+    let filesToAnalyze;
+    if (options.changed) {
+        const gitInfo = getGitInfo(rootDir);
+        if (!gitInfo.isGitRepo) {
+            console.error(chalk.red('Error: --changed requires a git repository'));
+            process.exit(1);
+        }
+        const modifiedFiles = getAllModifiedFiles(rootDir);
+        filesToAnalyze = filterReactFiles(modifiedFiles);
+        if (filesToAnalyze.length === 0) {
+            console.log(chalk.green('✓ No modified React files to analyze'));
+            process.exit(0);
+        }
+        console.log(chalk.cyan(`\n📝 Analyzing ${filesToAnalyze.length} modified file(s)...\n`));
+    }
+    const spinner = ora('Analyzing React project...').start();
+    try {
+        const result = await analyzeProject({
+            rootDir,
+            include: filesToAnalyze ? undefined : include,
+            exclude: filesToAnalyze ? undefined : exclude,
+            config,
         });
         spinner.stop();
+        // Initialize baseline if enabled
+        if (options.baseline) {
+            initializeBaseline(rootDir);
+        }
+        // Fix mode - apply auto-fixes
+        if (options.fix) {
+            const fixableSmells = result.files.flatMap(f => f.smells.filter(isFixable).map(s => ({ ...s, file: f.file })));
+            if (fixableSmells.length > 0) {
+                console.log(chalk.cyan(`\n🔧 Auto-fixing ${fixableSmells.length} issue(s)...\n`));
+                // Group by file
+                const smellsByFile = new Map();
+                fixableSmells.forEach(smell => {
+                    const existing = smellsByFile.get(smell.file) || [];
+                    existing.push(smell);
+                    smellsByFile.set(smell.file, existing);
+                });
+                let totalFixed = 0;
+                for (const [file, smells] of smellsByFile) {
+                    const fixResult = await fixFile(file, smells);
+                    if (fixResult.fixedSmells.length > 0) {
+                        console.log(chalk.green(`  ✓ Fixed ${fixResult.fixedSmells.length} issue(s) in ${path.relative(rootDir, file)}`));
+                        totalFixed += fixResult.fixedSmells.length;
+                    }
+                }
+                console.log(chalk.green(`\n✓ Fixed ${totalFixed} issue(s) total\n`));
+                // Re-analyze after fixes
+                const newResult = await analyzeProject({ rootDir, include, exclude, config });
+                console.log(chalk.dim(`Remaining issues: ${newResult.summary.totalSmells}\n`));
+            }
+            else {
+                console.log(chalk.yellow('\nNo auto-fixable issues found\n'));
+            }
+        }
         let output;
         if (options.format === 'html') {
             output = generateHTMLReport(result, rootDir);
@@ -89,6 +167,27 @@ program
         else {
             console.log(output);
         }
+        // Record baseline and show trend analysis
+        if (options.baseline) {
+            const gitInfo = getGitInfo(rootDir);
+            const baselineRecord = recordBaseline(rootDir, result.files.flatMap(f => f.smells), gitInfo.currentCommit);
+            console.log(formatTrendReport(rootDir));
+        }
+        // Send webhook notification
+        const webhookConfig = getWebhookConfig(options.slack, options.discord, options.webhook);
+        if (webhookConfig) {
+            webhookConfig.threshold = options.webhookThreshold;
+            const gitInfo = getGitInfo(rootDir);
+            const metadata = {
+                branch: gitInfo.branch,
+                commit: gitInfo.currentCommit,
+                author: gitInfo.authorName,
+            };
+            const sent = await sendWebhookNotification(webhookConfig, result.files.flatMap(f => f.smells), path.basename(rootDir), metadata);
+            if (sent) {
+                console.log(chalk.green('✓ Notification sent to webhook'));
+            }
+        }
         // CI/CD exit code handling
         const { smellsBySeverity } = result.summary;
         let shouldFail = false;

package/dist/detectors/complexity.d.ts

@@ -0,0 +1,17 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+export interface ComplexityMetrics {
+    cyclomaticComplexity: number;
+    cognitiveComplexity: number;
+    maxNestingDepth: number;
+    linesOfCode: number;
+}
+/**
+ * Detect code complexity issues in a component
+ */
+export declare function detectComplexity(component: ParsedComponent, filePath: string, sourceCode: string, config: DetectorConfig): CodeSmell[];
+/**
+ * Calculate complexity metrics for a component
+ */
+export declare function calculateComplexityMetrics(component: ParsedComponent): ComplexityMetrics;
+//# sourceMappingURL=complexity.d.ts.map

package/dist/detectors/complexity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complexity.d.ts","sourceRoot":"","sources":["../../src/detectors/complexity.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE9D,MAAM,WAAW,iBAAiB;IAChC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,GACrB,SAAS,EAAE,CAqCb;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,eAAe,GAAG,iBAAiB,CA6BxF"}

package/dist/detectors/complexity.js

@@ -0,0 +1,69 @@
+/**
+ * Detect code complexity issues in a component
+ */
+export function detectComplexity(component, filePath, sourceCode, config) {
+    if (!config.checkComplexity)
+        return [];
+    const smells = [];
+    const metrics = calculateComplexityMetrics(component);
+    const thresholds = {
+        cyclomatic: config.maxCyclomaticComplexity || 10,
+        cognitive: config.maxCognitiveComplexity || 15,
+        nesting: config.maxNestingDepth || 4,
+    };
+    if (metrics.cyclomaticComplexity > thresholds.cyclomatic) {
+        smells.push({
+            type: 'high-cyclomatic-complexity',
+            severity: metrics.cyclomaticComplexity > thresholds.cyclomatic * 1.5 ? 'error' : 'warning',
+            message: `Component "${component.name}" has cyclomatic complexity of ${metrics.cyclomaticComplexity} (threshold: ${thresholds.cyclomatic})`,
+            file: filePath,
+            line: component.startLine,
+            column: 0,
+            suggestion: 'Break down complex logic into smaller functions.',
+        });
+    }
+    if (metrics.cognitiveComplexity > thresholds.cognitive) {
+        smells.push({
+            type: 'high-cognitive-complexity',
+            severity: metrics.cognitiveComplexity > thresholds.cognitive * 1.5 ? 'error' : 'warning',
+            message: `Component "${component.name}" has cognitive complexity of ${metrics.cognitiveComplexity} (threshold: ${thresholds.cognitive})`,
+            file: filePath,
+            line: component.startLine,
+            column: 0,
+            suggestion: 'Simplify nested conditions and flatten control flow.',
+        });
+    }
+    return smells;
+}
+/**
+ * Calculate complexity metrics for a component
+ */
+export function calculateComplexityMetrics(component) {
+    let cyclomaticComplexity = 1;
+    let cognitiveComplexity = 0;
+    component.path.traverse({
+        IfStatement() { cyclomaticComplexity++; cognitiveComplexity++; },
+        ConditionalExpression() { cyclomaticComplexity++; cognitiveComplexity++; },
+        LogicalExpression(path) {
+            if (path.node.operator === '&&' || path.node.operator === '||') {
+                cyclomaticComplexity++;
+            }
+        },
+        SwitchCase(path) {
+            if (path.node.test !== null)
+                cyclomaticComplexity++;
+        },
+        ForStatement() { cyclomaticComplexity++; cognitiveComplexity += 2; },
+        ForInStatement() { cyclomaticComplexity++; cognitiveComplexity += 2; },
+        ForOfStatement() { cyclomaticComplexity++; cognitiveComplexity += 2; },
+        WhileStatement() { cyclomaticComplexity++; cognitiveComplexity += 2; },
+        DoWhileStatement() { cyclomaticComplexity++; cognitiveComplexity += 2; },
+        CatchClause() { cyclomaticComplexity++; cognitiveComplexity++; },
+    });
+    return {
+        cyclomaticComplexity,
+        cognitiveComplexity,
+        maxNestingDepth: component.jsxDepth,
+        linesOfCode: component.endLine - component.startLine + 1,
+    };
+}

package/dist/detectors/imports.d.ts

@@ -0,0 +1,22 @@
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+export interface ImportInfo {
+    source: string;
+    specifiers: string[];
+    line: number;
+    isDefault: boolean;
+    isNamespace: boolean;
+}
+export interface ImportAnalysisResult {
+    smells: CodeSmell[];
+    importGraph: Map<string, string[]>;
+    circularDeps: string[][];
+}
+/**
+ * Analyze imports across multiple files for issues
+ */
+export declare function analyzeImports(files: string[], rootDir: string, config: DetectorConfig): Promise<ImportAnalysisResult>;
+/**
+ * Standalone detection function matching other detector signatures
+ */
+export declare function detectImportIssues(component: any, filePath: string, sourceCode: string, config: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=imports.d.ts.map

package/dist/detectors/imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../src/detectors/imports.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAK9D,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACnC,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,oBAAoB,CAAC,CAkD/B;AA8KD;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,GAAG,EACd,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,GACrB,SAAS,EAAE,CAGb"}

package/dist/detectors/imports.js

@@ -0,0 +1,210 @@
+import * as t from '@babel/types';
+import _traverse from '@babel/traverse';
+import { parse } from '@babel/parser';
+import fs from 'fs/promises';
+import path from 'path';
+// Handle ESM/CJS interop
+const traverse = typeof _traverse === 'function' ? _traverse : _traverse.default;
+/**
+ * Analyze imports across multiple files for issues
+ */
+export async function analyzeImports(files, rootDir, config) {
+    const smells = [];
+    const importGraph = new Map();
+    // Build import graph
+    for (const file of files) {
+        try {
+            const content = await fs.readFile(file, 'utf-8');
+            const imports = extractImports(content, file);
+            const resolvedImports = [];
+            for (const imp of imports) {
+                // Skip external packages
+                if (!imp.source.startsWith('.') && !imp.source.startsWith('/')) {
+                    continue;
+                }
+                const resolvedPath = resolveImportPath(file, imp.source, rootDir);
+                if (resolvedPath) {
+                    resolvedImports.push(resolvedPath);
+                }
+            }
+            importGraph.set(file, resolvedImports);
+            // Detect import-related smells in this file
+            smells.push(...detectImportSmells(imports, file, content, config));
+        }
+        catch {
+            // Skip files that can't be parsed
+        }
+    }
+    // Detect circular dependencies
+    const circularDeps = detectCircularDependencies(importGraph);
+    // Add circular dependency smells
+    for (const cycle of circularDeps) {
+        const cycleStr = cycle.map(f => path.basename(f)).join(' → ');
+        smells.push({
+            type: 'circular-dependency',
+            severity: 'warning',
+            message: `Circular dependency detected: ${cycleStr}`,
+            file: cycle[0],
+            line: 1,
+            column: 0,
+            suggestion: 'Refactor to break the cycle. Consider extracting shared logic to a separate module.',
+        });
+    }
+    return { smells, importGraph, circularDeps };
+}
+/**
+ * Extract all imports from a file
+ */
+function extractImports(sourceCode, filePath) {
+    const imports = [];
+    try {
+        const ast = parse(sourceCode, {
+            sourceType: 'module',
+            plugins: ['jsx', 'typescript'],
+        });
+        traverse(ast, {
+            ImportDeclaration(nodePath) {
+                const node = nodePath.node;
+                const specifiers = node.specifiers.map(spec => {
+                    if (t.isImportDefaultSpecifier(spec))
+                        return 'default';
+                    if (t.isImportNamespaceSpecifier(spec))
+                        return '*';
+                    return spec.local.name;
+                });
+                imports.push({
+                    source: node.source.value,
+                    specifiers,
+                    line: node.loc?.start.line || 0,
+                    isDefault: node.specifiers.some(t.isImportDefaultSpecifier),
+                    isNamespace: node.specifiers.some(t.isImportNamespaceSpecifier),
+                });
+            },
+        });
+    }
+    catch {
+        // Parse error, skip
+    }
+    return imports;
+}
+/**
+ * Resolve an import path relative to the importing file
+ */
+function resolveImportPath(fromFile, importSource, rootDir) {
+    if (!importSource.startsWith('.')) {
+        return null; // External package
+    }
+    const dir = path.dirname(fromFile);
+    let resolved = path.resolve(dir, importSource);
+    // Try common extensions
+    const extensions = ['.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts', '/index.jsx', '/index.js'];
+    for (const ext of extensions) {
+        const tryPath = resolved + ext;
+        // We don't check existence here - just build the graph
+        if (!ext.includes('/')) {
+            return tryPath;
+        }
+    }
+    return resolved;
+}
+/**
+ * Detect circular dependencies in import graph using DFS
+ */
+function detectCircularDependencies(graph) {
+    const cycles = [];
+    const visited = new Set();
+    const recursionStack = new Set();
+    const path = [];
+    function dfs(node) {
+        visited.add(node);
+        recursionStack.add(node);
+        path.push(node);
+        const neighbors = graph.get(node) || [];
+        for (const neighbor of neighbors) {
+            if (!visited.has(neighbor)) {
+                dfs(neighbor);
+            }
+            else if (recursionStack.has(neighbor)) {
+                // Found a cycle
+                const cycleStart = path.indexOf(neighbor);
+                if (cycleStart !== -1) {
+                    const cycle = path.slice(cycleStart).concat(neighbor);
+                    // Avoid duplicate cycles
+                    const cycleKey = [...cycle].sort().join('|');
+                    if (!cycles.some(c => [...c].sort().join('|') === cycleKey)) {
+                        cycles.push(cycle);
+                    }
+                }
+            }
+        }
+        path.pop();
+        recursionStack.delete(node);
+    }
+    for (const node of graph.keys()) {
+        if (!visited.has(node)) {
+            dfs(node);
+        }
+    }
+    return cycles;
+}
+/**
+ * Detect import-related code smells in a single file
+ */
+function detectImportSmells(imports, filePath, sourceCode, config) {
+    const smells = [];
+    // Check for barrel file imports (importing from index files)
+    for (const imp of imports) {
+        if (imp.source.endsWith('/index') || imp.source === '.') {
+            smells.push({
+                type: 'barrel-file-import',
+                severity: 'info',
+                message: `Barrel file import from "${imp.source}" may impact tree-shaking`,
+                file: filePath,
+                line: imp.line,
+                column: 0,
+                suggestion: 'Import directly from the source file instead of barrel/index files for better build optimization.',
+            });
+        }
+    }
+    // Check for namespace imports (import * as)
+    for (const imp of imports) {
+        if (imp.isNamespace && !imp.source.startsWith('.')) {
+            smells.push({
+                type: 'namespace-import',
+                severity: 'info',
+                message: `Namespace import "* as" from "${imp.source}" may prevent tree-shaking`,
+                file: filePath,
+                line: imp.line,
+                column: 0,
+                suggestion: 'Import only the specific exports you need for better bundle size.',
+            });
+        }
+    }
+    // Check for too many imports from same source
+    const importCounts = new Map();
+    for (const imp of imports) {
+        const count = (importCounts.get(imp.source) || 0) + imp.specifiers.length;
+        importCounts.set(imp.source, count);
+    }
+    for (const [source, count] of importCounts) {
+        if (count > 10 && source.startsWith('.')) {
+            smells.push({
+                type: 'excessive-imports',
+                severity: 'warning',
+                message: `${count} imports from "${source}" suggests tight coupling`,
+                file: filePath,
+                line: imports.find(i => i.source === source)?.line || 1,
+                column: 0,
+                suggestion: 'Consider if this file has too many responsibilities or if modules should be reorganized.',
+            });
+        }
+    }
+    return smells;
+}
+/**
+ * Standalone detection function matching other detector signatures
+ */
+export function detectImportIssues(component, filePath, sourceCode, config) {
+    const imports = extractImports(sourceCode, filePath);
+    return detectImportSmells(imports, filePath, sourceCode, config);
+}

package/dist/detectors/index.d.ts

@@ -16,4 +16,8 @@ export { detectTypescriptIssues } from './typescript.js';
 export { detectDebugStatements } from './debug.js';
 export { detectSecurityIssues } from './security.js';
 export { detectAccessibilityIssues } from './accessibility.js';
+export { detectComplexity, calculateComplexityMetrics } from './complexity.js';
+export { detectMemoryLeaks } from './memoryLeak.js';
+export { detectImportIssues, analyzeImports } from './imports.js';
+export { detectUnusedCode } from './unusedCode.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/detectors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/detectors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/detectors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/detectors/index.js

@@ -18,3 +18,8 @@ export { detectTypescriptIssues } from './typescript.js';
 export { detectDebugStatements } from './debug.js';
 export { detectSecurityIssues } from './security.js';
 export { detectAccessibilityIssues } from './accessibility.js';
+// Complexity, Memory Leaks, Imports
+export { detectComplexity, calculateComplexityMetrics } from './complexity.js';
+export { detectMemoryLeaks } from './memoryLeak.js';
+export { detectImportIssues, analyzeImports } from './imports.js';
+export { detectUnusedCode } from './unusedCode.js';

package/dist/detectors/memoryLeak.d.ts

@@ -0,0 +1,7 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detect potential memory leaks in React components
+ */
+export declare function detectMemoryLeaks(component: ParsedComponent, filePath: string, sourceCode: string, config: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=memoryLeak.d.ts.map

package/dist/detectors/memoryLeak.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryLeak.d.ts","sourceRoot":"","sources":["../../src/detectors/memoryLeak.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE9D;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,GACrB,SAAS,EAAE,CAgEb"}