react-code-smell-detector 1.0.0 → 1.0.1

package/dist/analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,cAAc,EAMd,cAAc,EAIf,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CAClC;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CA0CtF;AA+ID,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAgBA,OAAO,EACL,cAAc,EAMd,cAAc,EAIf,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CAClC;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CA0CtF;AA2JD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/analyzer.js

@@ -1,7 +1,7 @@
 import fg from 'fast-glob';
 import path from 'path';
 import { parseFile } from './parser/index.js';
-import { detectUseEffectOveruse, detectPropDrilling, analyzePropDrillingDepth, detectLargeComponent, detectUnmemoizedCalculations, } from './detectors/index.js';
+import { detectUseEffectOveruse, detectPropDrilling, analyzePropDrillingDepth, detectLargeComponent, detectUnmemoizedCalculations, detectMissingKeys, detectHooksRulesViolations, detectDependencyArrayIssues, detectNestedTernaries, detectDeadCode, detectMagicValues, } from './detectors/index.js';
 import { DEFAULT_CONFIG, } from './types/index.js';
 export async function analyzeProject(options) {
     const { rootDir, include = ['**/*.tsx', '**/*.jsx'], exclude = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/*.test.*', '**/*.spec.*'], config: userConfig = {}, } = options;
@@ -62,6 +62,12 @@ function analyzeFile(parseResult, filePath, config) {
         smells.push(...detectPropDrilling(component, filePath, sourceCode, config));
         smells.push(...detectLargeComponent(component, filePath, sourceCode, config));
         smells.push(...detectUnmemoizedCalculations(component, filePath, sourceCode, config));
+        smells.push(...detectMissingKeys(component, filePath, sourceCode, config));
+        smells.push(...detectHooksRulesViolations(component, filePath, sourceCode, config));
+        smells.push(...detectDependencyArrayIssues(component, filePath, sourceCode, config));
+        smells.push(...detectNestedTernaries(component, filePath, sourceCode, config));
+        smells.push(...detectDeadCode(component, filePath, sourceCode, config));
+        smells.push(...detectMagicValues(component, filePath, sourceCode, config));
     });
     // Run cross-component analysis
     smells.push(...analyzePropDrillingDepth(components, filePath, sourceCode, config));
@@ -82,6 +88,12 @@ function calculateSummary(files) {
         'state-in-loop': 0,
         'inline-function-prop': 0,
         'deep-nesting': 0,
+        'missing-key': 0,
+        'hooks-rules-violation': 0,
+        'dependency-array-issue': 0,
+        'nested-ternary': 0,
+        'dead-code': 0,
+        'magic-value': 0,
     };
     const smellsBySeverity = {
         error: 0,

package/dist/detectors/deadCode.d.ts

@@ -0,0 +1,14 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects potentially dead code: unused variables, imports, and functions
+ */
+export declare function detectDeadCode(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig): CodeSmell[];
+/**
+ * Detects unused imports at the file level
+ */
+export declare function detectUnusedImports(imports: Map<string, {
+    source: string;
+    line: number;
+}>, usedInFile: Set<string>, filePath: string, sourceCode: string): CodeSmell[];
+//# sourceMappingURL=deadCode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deadCode.d.ts","sourceRoot":"","sources":["../../src/detectors/deadCode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAkB,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAkB,MAAM,mBAAmB,CAAC;AAE9E;;GAEG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,cAA+B,GACtC,SAAS,EAAE,CAsHb;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EACtD,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EACvB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,SAAS,EAAE,CAsBb"}

package/dist/detectors/deadCode.js

@@ -0,0 +1,141 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects potentially dead code: unused variables, imports, and functions
+ */
+export function detectDeadCode(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    if (!config.checkDeadCode)
+        return [];
+    const smells = [];
+    // Track declared and used identifiers within the component
+    const declared = new Map();
+    const used = new Set();
+    // Collect all declared variables in the component
+    component.path.traverse({
+        VariableDeclarator(path) {
+            if (t.isIdentifier(path.node.id)) {
+                const loc = path.node.loc;
+                declared.set(path.node.id.name, {
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    type: 'variable',
+                });
+            }
+            else if (t.isObjectPattern(path.node.id)) {
+                // Destructured variables
+                path.node.id.properties.forEach(prop => {
+                    if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
+                        const loc = prop.loc;
+                        declared.set(prop.value.name, {
+                            line: loc?.start.line || 0,
+                            column: loc?.start.column || 0,
+                            type: 'variable',
+                        });
+                    }
+                    else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
+                        const loc = prop.loc;
+                        declared.set(prop.argument.name, {
+                            line: loc?.start.line || 0,
+                            column: loc?.start.column || 0,
+                            type: 'variable',
+                        });
+                    }
+                });
+            }
+            else if (t.isArrayPattern(path.node.id)) {
+                // Array destructured variables
+                path.node.id.elements.forEach(elem => {
+                    if (t.isIdentifier(elem)) {
+                        const loc = elem.loc;
+                        declared.set(elem.name, {
+                            line: loc?.start.line || 0,
+                            column: loc?.start.column || 0,
+                            type: 'variable',
+                        });
+                    }
+                });
+            }
+        },
+        FunctionDeclaration(path) {
+            if (path.node.id) {
+                const loc = path.node.loc;
+                declared.set(path.node.id.name, {
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    type: 'function',
+                });
+            }
+        },
+    });
+    // Collect all used identifiers
+    component.path.traverse({
+        Identifier(path) {
+            // Skip if it's a declaration
+            if (t.isVariableDeclarator(path.parent) && path.parent.id === path.node ||
+                t.isFunctionDeclaration(path.parent) && path.parent.id === path.node ||
+                t.isObjectProperty(path.parent) && path.parent.key === path.node ||
+                t.isImportSpecifier(path.parent) ||
+                t.isImportDefaultSpecifier(path.parent)) {
+                return;
+            }
+            // Skip property access (x.y - y is not a reference)
+            if (t.isMemberExpression(path.parent) && path.parent.property === path.node && !path.parent.computed) {
+                return;
+            }
+            used.add(path.node.name);
+        },
+        JSXIdentifier(path) {
+            // Components used in JSX
+            if (t.isJSXOpeningElement(path.parent) || t.isJSXClosingElement(path.parent)) {
+                used.add(path.node.name);
+            }
+        },
+    });
+    // Find unused declarations
+    declared.forEach((info, name) => {
+        // Skip hooks and common patterns
+        if (name.startsWith('_') || name.startsWith('set'))
+            return;
+        // Skip if it's the component name itself
+        if (name === component.name)
+            return;
+        if (!used.has(name)) {
+            smells.push({
+                type: 'dead-code',
+                severity: 'info',
+                message: `Unused ${info.type} "${name}" in "${component.name}"`,
+                file: filePath,
+                line: info.line,
+                column: info.column,
+                suggestion: `Remove the unused ${info.type} or use it in the component.`,
+                codeSnippet: getCodeSnippet(sourceCode, info.line),
+            });
+        }
+    });
+    return smells;
+}
+/**
+ * Detects unused imports at the file level
+ */
+export function detectUnusedImports(imports, usedInFile, filePath, sourceCode) {
+    const smells = [];
+    imports.forEach((info, name) => {
+        // Skip React imports as they might be used implicitly
+        if (name === 'React' || info.source === 'react')
+            return;
+        if (!usedInFile.has(name)) {
+            smells.push({
+                type: 'dead-code',
+                severity: 'info',
+                message: `Unused import "${name}" from "${info.source}"`,
+                file: filePath,
+                line: info.line,
+                column: 0,
+                suggestion: `Remove the unused import: import { ${name} } from '${info.source}'`,
+                codeSnippet: getCodeSnippet(sourceCode, info.line),
+            });
+        }
+    });
+    return smells;
+}

package/dist/detectors/dependencyArray.d.ts

@@ -0,0 +1,7 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects potential issues with useEffect dependency arrays
+ */
+export declare function detectDependencyArrayIssues(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=dependencyArray.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dependencyArray.d.ts","sourceRoot":"","sources":["../../src/detectors/dependencyArray.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAkB,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAkB,MAAM,mBAAmB,CAAC;AAE9E;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,cAA+B,GACtC,SAAS,EAAE,CA4Hb"}

package/dist/detectors/dependencyArray.js

@@ -0,0 +1,164 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects potential issues with useEffect dependency arrays
+ */
+export function detectDependencyArrayIssues(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    if (!config.checkDependencyArrays)
+        return [];
+    const smells = [];
+    // Analyze each useEffect
+    component.hooks.useEffect.forEach(effectCall => {
+        const args = effectCall.arguments;
+        const callback = args[0];
+        const depsArray = args[1];
+        const loc = effectCall.loc;
+        const line = loc?.start.line || 0;
+        // Check 1: Missing dependency array entirely
+        if (!depsArray) {
+            smells.push({
+                type: 'dependency-array-issue',
+                severity: 'warning',
+                message: `useEffect without dependency array in "${component.name}" runs on every render`,
+                file: filePath,
+                line,
+                column: loc?.start.column || 0,
+                suggestion: 'Add a dependency array. Use [] for mount-only effect, or [dep1, dep2] for reactive dependencies.',
+                codeSnippet: getCodeSnippet(sourceCode, line),
+            });
+            return;
+        }
+        // Check 2: Empty dependency array with variables used inside
+        if (t.isArrayExpression(depsArray) && depsArray.elements.length === 0) {
+            // Collect variables used in the effect callback
+            const usedVariables = new Set();
+            if (t.isArrowFunctionExpression(callback) || t.isFunctionExpression(callback)) {
+                collectVariablesUsed(callback.body, usedVariables);
+                // Filter out common globals and React hooks
+                const globals = new Set(['console', 'window', 'document', 'setTimeout', 'setInterval',
+                    'clearTimeout', 'clearInterval', 'fetch', 'Promise', 'JSON', 'Math', 'Date', 'Array',
+                    'Object', 'String', 'Number', 'Boolean', 'Error', 'undefined', 'null', 'true', 'false']);
+                // Check if there are local variables that might need to be dependencies
+                const potentialMissing = [...usedVariables].filter(v => !globals.has(v) &&
+                    !v.startsWith('set') && // Setters from useState are stable
+                    v !== 'props' &&
+                    v !== 'children');
+                // Only warn if there appear to be external variables used
+                if (potentialMissing.length > 3) {
+                    smells.push({
+                        type: 'dependency-array-issue',
+                        severity: 'info',
+                        message: `useEffect in "${component.name}" has empty deps array but uses external variables`,
+                        file: filePath,
+                        line,
+                        column: loc?.start.column || 0,
+                        suggestion: `Consider adding dependencies: [${potentialMissing.slice(0, 3).join(', ')}...]`,
+                        codeSnippet: getCodeSnippet(sourceCode, line),
+                    });
+                }
+            }
+        }
+        // Check 3: Dependency array with object/array literals
+        if (t.isArrayExpression(depsArray)) {
+            depsArray.elements.forEach((elem, index) => {
+                if (t.isObjectExpression(elem) || t.isArrayExpression(elem)) {
+                    smells.push({
+                        type: 'dependency-array-issue',
+                        severity: 'warning',
+                        message: `Object/array literal in useEffect dependency array in "${component.name}" causes infinite re-renders`,
+                        file: filePath,
+                        line,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Move the object/array to a useMemo or extract to a constant outside the component.',
+                        codeSnippet: getCodeSnippet(sourceCode, line),
+                    });
+                }
+                // Check for inline functions
+                if (t.isArrowFunctionExpression(elem) || t.isFunctionExpression(elem)) {
+                    smells.push({
+                        type: 'dependency-array-issue',
+                        severity: 'warning',
+                        message: `Inline function in useEffect dependency array in "${component.name}" causes infinite re-renders`,
+                        file: filePath,
+                        line,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Wrap the function in useCallback before using as a dependency.',
+                        codeSnippet: getCodeSnippet(sourceCode, line),
+                    });
+                }
+            });
+        }
+    });
+    // Also check useMemo and useCallback
+    [...component.hooks.useMemo, ...component.hooks.useCallback].forEach(hookCall => {
+        const depsArray = hookCall.arguments[1];
+        const loc = hookCall.loc;
+        const line = loc?.start.line || 0;
+        if (!depsArray) {
+            const hookName = t.isIdentifier(hookCall.callee)
+                ? (hookCall.callee.name)
+                : 'useMemo/useCallback';
+            smells.push({
+                type: 'dependency-array-issue',
+                severity: 'warning',
+                message: `${hookName} without dependency array in "${component.name}"`,
+                file: filePath,
+                line,
+                column: loc?.start.column || 0,
+                suggestion: 'Add a dependency array to specify when the value should be recalculated.',
+                codeSnippet: getCodeSnippet(sourceCode, line),
+            });
+        }
+    });
+    return smells;
+}
+/**
+ * Helper to collect variable names used in a code block
+ */
+function collectVariablesUsed(node, variables) {
+    if (t.isIdentifier(node)) {
+        variables.add(node.name);
+    }
+    else if (t.isMemberExpression(node)) {
+        if (t.isIdentifier(node.object)) {
+            variables.add(node.object.name);
+        }
+        else {
+            collectVariablesUsed(node.object, variables);
+        }
+    }
+    else if (t.isBlockStatement(node)) {
+        node.body.forEach(stmt => collectVariablesUsed(stmt, variables));
+    }
+    else if (t.isExpressionStatement(node)) {
+        collectVariablesUsed(node.expression, variables);
+    }
+    else if (t.isCallExpression(node)) {
+        if (t.isIdentifier(node.callee)) {
+            variables.add(node.callee.name);
+        }
+        node.arguments.forEach(arg => {
+            if (t.isNode(arg))
+                collectVariablesUsed(arg, variables);
+        });
+    }
+    else if (t.isConditionalExpression(node)) {
+        collectVariablesUsed(node.test, variables);
+        collectVariablesUsed(node.consequent, variables);
+        collectVariablesUsed(node.alternate, variables);
+    }
+    else if (t.isBinaryExpression(node) || t.isLogicalExpression(node)) {
+        collectVariablesUsed(node.left, variables);
+        collectVariablesUsed(node.right, variables);
+    }
+    else if (t.isReturnStatement(node) && node.argument) {
+        collectVariablesUsed(node.argument, variables);
+    }
+    else if (t.isIfStatement(node)) {
+        collectVariablesUsed(node.test, variables);
+        collectVariablesUsed(node.consequent, variables);
+        if (node.alternate)
+            collectVariablesUsed(node.alternate, variables);
+    }
+}

package/dist/detectors/hooksRules.d.ts

@@ -0,0 +1,7 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects hooks used inside conditionals or loops (violates Rules of Hooks)
+ */
+export declare function detectHooksRulesViolations(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=hooksRules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooksRules.d.ts","sourceRoot":"","sources":["../../src/detectors/hooksRules.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAkB,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAkB,MAAM,mBAAmB,CAAC;AAE9E;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,cAA+B,GACtC,SAAS,EAAE,CAuFb"}

package/dist/detectors/hooksRules.js

@@ -0,0 +1,81 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects hooks used inside conditionals or loops (violates Rules of Hooks)
+ */
+export function detectHooksRulesViolations(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    if (!config.checkHooksRules)
+        return [];
+    const smells = [];
+    const hooks = [
+        'useState', 'useEffect', 'useContext', 'useReducer', 'useCallback',
+        'useMemo', 'useRef', 'useImperativeHandle', 'useLayoutEffect',
+        'useDebugValue', 'useDeferredValue', 'useTransition', 'useId',
+    ];
+    component.path.traverse({
+        CallExpression(path) {
+            // Check if it's a hook call
+            const callee = path.node.callee;
+            let hookName = null;
+            if (t.isIdentifier(callee) && hooks.includes(callee.name)) {
+                hookName = callee.name;
+            }
+            else if (t.isIdentifier(callee) && callee.name.startsWith('use') && callee.name[3]?.toUpperCase() === callee.name[3]) {
+                // Custom hooks (useXxx pattern)
+                hookName = callee.name;
+            }
+            if (!hookName)
+                return;
+            // Check if hook is inside a conditional or loop
+            let currentPath = path.parentPath;
+            while (currentPath) {
+                const node = currentPath.node;
+                // Check for conditionals
+                if (t.isIfStatement(node) || t.isConditionalExpression(node)) {
+                    const loc = path.node.loc;
+                    smells.push({
+                        type: 'hooks-rules-violation',
+                        severity: 'error',
+                        message: `Hook "${hookName}" called inside a conditional in "${component.name}"`,
+                        file: filePath,
+                        line: loc?.start.line || 0,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Hooks must be called at the top level of the component. Move the hook call outside the conditional.',
+                        codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                    });
+                    break;
+                }
+                // Check for loops
+                if (t.isForStatement(node) ||
+                    t.isWhileStatement(node) ||
+                    t.isDoWhileStatement(node) ||
+                    t.isForInStatement(node) ||
+                    t.isForOfStatement(node)) {
+                    const loc = path.node.loc;
+                    smells.push({
+                        type: 'hooks-rules-violation',
+                        severity: 'error',
+                        message: `Hook "${hookName}" called inside a loop in "${component.name}"`,
+                        file: filePath,
+                        line: loc?.start.line || 0,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Hooks must be called at the top level. Consider restructuring to avoid calling hooks in loops.',
+                        codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                    });
+                    break;
+                }
+                // Check for early return before hook (within same function)
+                // This would require more complex flow analysis
+                // Stop traversing when we reach the component function
+                if (t.isFunctionDeclaration(node) ||
+                    t.isArrowFunctionExpression(node) ||
+                    t.isFunctionExpression(node)) {
+                    break;
+                }
+                currentPath = currentPath.parentPath;
+            }
+        },
+    });
+    return smells;
+}

package/dist/detectors/index.d.ts

@@ -2,4 +2,10 @@ export { detectUseEffectOveruse } from './useEffect.js';
 export { detectPropDrilling, analyzePropDrillingDepth } from './propDrilling.js';
 export { detectLargeComponent } from './largeComponent.js';
 export { detectUnmemoizedCalculations } from './memoization.js';
+export { detectMissingKeys } from './missingKey.js';
+export { detectHooksRulesViolations } from './hooksRules.js';
+export { detectDependencyArrayIssues } from './dependencyArray.js';
+export { detectNestedTernaries } from './nestedTernary.js';
+export { detectDeadCode, detectUnusedImports } from './deadCode.js';
+export { detectMagicValues } from './magicValues.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"}
+{"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"}

package/dist/detectors/index.js

@@ -2,3 +2,9 @@ export { detectUseEffectOveruse } from './useEffect.js';
 export { detectPropDrilling, analyzePropDrillingDepth } from './propDrilling.js';
 export { detectLargeComponent } from './largeComponent.js';
 export { detectUnmemoizedCalculations } from './memoization.js';
+export { detectMissingKeys } from './missingKey.js';
+export { detectHooksRulesViolations } from './hooksRules.js';
+export { detectDependencyArrayIssues } from './dependencyArray.js';
+export { detectNestedTernaries } from './nestedTernary.js';
+export { detectDeadCode, detectUnusedImports } from './deadCode.js';
+export { detectMagicValues } from './magicValues.js';

package/dist/detectors/magicValues.d.ts

@@ -0,0 +1,7 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects magic numbers and strings that should be constants
+ */
+export declare function detectMagicValues(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=magicValues.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"magicValues.d.ts","sourceRoot":"","sources":["../../src/detectors/magicValues.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAkB,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAkB,MAAM,mBAAmB,CAAC;AAE9E;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,cAA+B,GACtC,SAAS,EAAE,CAqGb"}

package/dist/detectors/magicValues.js

@@ -0,0 +1,99 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects magic numbers and strings that should be constants
+ */
+export function detectMagicValues(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    if (!config.checkMagicValues)
+        return [];
+    const smells = [];
+    const threshold = config.magicNumberThreshold;
+    // Track locations to avoid duplicate reports
+    const reportedLines = new Set();
+    component.path.traverse({
+        NumericLiteral(path) {
+            const value = path.node.value;
+            const loc = path.node.loc;
+            const line = loc?.start.line || 0;
+            // Skip common acceptable values
+            if (value === 0 || value === 1 || value === -1 || value === 2 || value === 100)
+                return;
+            // Skip array indices and small numbers
+            if (value < threshold && value > -threshold)
+                return;
+            // Skip if inside an object key position (e.g., style objects)
+            if (t.isObjectProperty(path.parent) && path.parent.key === path.node)
+                return;
+            // Skip if it's a port number or similar config
+            if (value === 3000 || value === 8080 || value === 80 || value === 443)
+                return;
+            // Skip if already reported this line
+            if (reportedLines.has(line))
+                return;
+            reportedLines.add(line);
+            // Check context - skip if it's in a variable declaration that names the constant
+            if (t.isVariableDeclarator(path.parent)) {
+                const varName = t.isIdentifier(path.parent.id) ? path.parent.id.name : '';
+                // If variable name is UPPER_CASE, it's already a constant
+                if (varName === varName.toUpperCase() && varName.includes('_'))
+                    return;
+            }
+            smells.push({
+                type: 'magic-value',
+                severity: 'info',
+                message: `Magic number ${value} in "${component.name}"`,
+                file: filePath,
+                line,
+                column: loc?.start.column || 0,
+                suggestion: `Extract to a named constant: const DESCRIPTIVE_NAME = ${value}`,
+                codeSnippet: getCodeSnippet(sourceCode, line),
+            });
+        },
+        StringLiteral(path) {
+            const value = path.node.value;
+            const loc = path.node.loc;
+            const line = loc?.start.line || 0;
+            // Skip short strings, empty strings, common values
+            if (value.length < 10)
+                return;
+            // Skip if it looks like a URL, path, or import
+            if (value.startsWith('http') || value.startsWith('/') || value.startsWith('.'))
+                return;
+            // Skip if it's an import source
+            if (t.isImportDeclaration(path.parent))
+                return;
+            // Skip JSX text content (usually intentional)
+            if (t.isJSXText(path.parent) || t.isJSXExpressionContainer(path.parent))
+                return;
+            // Skip object property keys
+            if (t.isObjectProperty(path.parent) && path.parent.key === path.node)
+                return;
+            // Skip if already reported this line
+            if (reportedLines.has(line))
+                return;
+            // Skip common patterns
+            if (value.includes('className') ||
+                value.includes('px') ||
+                value.includes('rem') ||
+                value.includes('%'))
+                return;
+            // Check if it looks like a user-facing message or error
+            const looksLikeMessage = /^[A-Z][a-z]+.*[.!?]?$/.test(value) || value.includes(' ');
+            if (looksLikeMessage && value.length > 30) {
+                reportedLines.add(line);
+                smells.push({
+                    type: 'magic-value',
+                    severity: 'info',
+                    message: `Hardcoded string in "${component.name}" should be in constants or i18n`,
+                    file: filePath,
+                    line,
+                    column: loc?.start.column || 0,
+                    suggestion: `Extract to a constants file or use i18n: "${value.substring(0, 30)}..."`,
+                    codeSnippet: getCodeSnippet(sourceCode, line),
+                });
+            }
+        },
+    });
+    return smells;
+}

package/dist/detectors/missingKey.d.ts

@@ -0,0 +1,7 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects .map() calls that render JSX without a key prop
+ */
+export declare function detectMissingKeys(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=missingKey.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"missingKey.d.ts","sourceRoot":"","sources":["../../src/detectors/missingKey.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAkB,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAkB,MAAM,mBAAmB,CAAC;AAE9E;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,cAA+B,GACtC,SAAS,EAAE,CA4Fb"}