react-code-smell-detector 1.0.1 → 1.1.1

package/dist/detectors/reactNative.js

@@ -0,0 +1,135 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects React Native-specific code smells:
+ * - Inline styles instead of StyleSheet
+ * - Missing accessibility props
+ * - Performance anti-patterns
+ */
+export function detectReactNativeIssues(component, filePath, sourceCode, config = DEFAULT_CONFIG, imports = []) {
+    if (!config.checkReactNative)
+        return [];
+    // Only run on React Native projects
+    const isRNProject = imports.some(imp => imp.includes('react-native') || imp.includes('@react-native'));
+    if (!isRNProject)
+        return [];
+    const smells = [];
+    const inlineStyleLines = new Set();
+    // Check for inline styles instead of StyleSheet
+    component.path.traverse({
+        JSXAttribute(path) {
+            if (!t.isJSXIdentifier(path.node.name))
+                return;
+            if (path.node.name.name !== 'style')
+                return;
+            const value = path.node.value;
+            if (!t.isJSXExpressionContainer(value))
+                return;
+            // Check if it's an inline object (not a StyleSheet reference)
+            if (t.isObjectExpression(value.expression)) {
+                const loc = path.node.loc;
+                const line = loc?.start.line || 0;
+                if (!inlineStyleLines.has(line)) {
+                    inlineStyleLines.add(line);
+                    smells.push({
+                        type: 'rn-inline-style',
+                        severity: 'warning',
+                        message: `Inline style object in "${component.name}" - prefer StyleSheet.create()`,
+                        file: filePath,
+                        line,
+                        column: loc?.start.column || 0,
+                        suggestion: 'Use StyleSheet.create() for better performance: const styles = StyleSheet.create({ ... })',
+                        codeSnippet: getCodeSnippet(sourceCode, line),
+                    });
+                }
+            }
+        },
+    });
+    // Check for missing accessibility props on interactive elements
+    const interactiveComponents = ['TouchableOpacity', 'TouchableHighlight', 'Pressable', 'Button', 'TouchableWithoutFeedback'];
+    component.path.traverse({
+        JSXOpeningElement(path) {
+            if (!t.isJSXIdentifier(path.node.name))
+                return;
+            const componentName = path.node.name.name;
+            if (!interactiveComponents.includes(componentName))
+                return;
+            // Check for accessibility props
+            const hasAccessibilityLabel = path.node.attributes.some(attr => {
+                if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) {
+                    return ['accessibilityLabel', 'accessible', 'accessibilityRole', 'accessibilityHint'].includes(attr.name.name);
+                }
+                return false;
+            });
+            if (!hasAccessibilityLabel) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'rn-missing-accessibility',
+                    severity: 'info',
+                    message: `${componentName} missing accessibility props in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Add accessibilityLabel and accessibilityRole for screen readers',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    // Check for performance anti-patterns
+    component.path.traverse({
+        // Detect creating anonymous functions in render (for onPress, etc.)
+        JSXAttribute(path) {
+            if (!t.isJSXIdentifier(path.node.name))
+                return;
+            const propName = path.node.name.name;
+            if (!['onPress', 'onPressIn', 'onPressOut', 'onLongPress'].includes(propName))
+                return;
+            const value = path.node.value;
+            if (!t.isJSXExpressionContainer(value))
+                return;
+            // Check for arrow functions or function expressions
+            if (t.isArrowFunctionExpression(value.expression) || t.isFunctionExpression(value.expression)) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'rn-performance-issue',
+                    severity: 'info',
+                    message: `Inline function for ${propName} in "${component.name}" creates new reference each render`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Extract to useCallback or class method to prevent unnecessary re-renders',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+        // Detect array spreads in render that could be memoized
+        SpreadElement(path) {
+            const loc = path.node.loc;
+            // Only flag if inside JSX or return statement
+            let inJSX = false;
+            let current = path.parentPath;
+            while (current) {
+                if (t.isJSXElement(current.node) || t.isJSXFragment(current.node)) {
+                    inJSX = true;
+                    break;
+                }
+                current = current.parentPath;
+            }
+            if (inJSX && t.isArrayExpression(path.parent)) {
+                smells.push({
+                    type: 'rn-performance-issue',
+                    severity: 'info',
+                    message: `Array spread in render may cause performance issues in "${component.name}"`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Consider memoizing with useMemo if this array is passed as a prop',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+    });
+    return smells;
+}

package/dist/detectors/typescript.d.ts

@@ -0,0 +1,11 @@
+import { ParsedComponent } from '../parser/index.js';
+import { CodeSmell, DetectorConfig } from '../types/index.js';
+/**
+ * Detects TypeScript-specific code smells:
+ * - Overuse of 'any' type
+ * - Missing return type on functions
+ * - Non-null assertion operator (!)
+ * - Type assertions (as) that could be avoided
+ */
+export declare function detectTypescriptIssues(component: ParsedComponent, filePath: string, sourceCode: string, config?: DetectorConfig): CodeSmell[];
+//# sourceMappingURL=typescript.d.ts.map

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

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

package/dist/detectors/typescript.js

@@ -0,0 +1,135 @@
+import * as t from '@babel/types';
+import { getCodeSnippet } from '../parser/index.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+/**
+ * Detects TypeScript-specific code smells:
+ * - Overuse of 'any' type
+ * - Missing return type on functions
+ * - Non-null assertion operator (!)
+ * - Type assertions (as) that could be avoided
+ */
+export function detectTypescriptIssues(component, filePath, sourceCode, config = DEFAULT_CONFIG) {
+    if (!config.checkTypescript)
+        return [];
+    // Only run on TypeScript files
+    if (!filePath.endsWith('.ts') && !filePath.endsWith('.tsx'))
+        return [];
+    const smells = [];
+    // Detect 'any' type usage
+    component.path.traverse({
+        TSAnyKeyword(path) {
+            const loc = path.node.loc;
+            smells.push({
+                type: 'ts-any-usage',
+                severity: 'warning',
+                message: `Using "any" type in "${component.name}"`,
+                file: filePath,
+                line: loc?.start.line || 0,
+                column: loc?.start.column || 0,
+                suggestion: 'Use a specific type, "unknown", or create an interface',
+                codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+            });
+        },
+    });
+    // Detect functions without return type (only in complex functions)
+    component.path.traverse({
+        FunctionDeclaration(path) {
+            // Skip if function has explicit return type
+            if (path.node.returnType)
+                return;
+            // Check if function body has return statements
+            let hasReturn = false;
+            path.traverse({
+                ReturnStatement(returnPath) {
+                    if (returnPath.node.argument) {
+                        hasReturn = true;
+                    }
+                },
+            });
+            if (hasReturn) {
+                const loc = path.node.loc;
+                smells.push({
+                    type: 'ts-missing-return-type',
+                    severity: 'info',
+                    message: `Function "${path.node.id?.name || 'anonymous'}" missing return type`,
+                    file: filePath,
+                    line: loc?.start.line || 0,
+                    column: loc?.start.column || 0,
+                    suggestion: 'Add explicit return type: function name(): ReturnType { ... }',
+                    codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                });
+            }
+        },
+        ArrowFunctionExpression(path) {
+            // Only check arrow functions assigned to variables with 5+ lines
+            if (!path.node.returnType) {
+                const body = path.node.body;
+                // Skip simple arrow functions (single expression)
+                if (!t.isBlockStatement(body))
+                    return;
+                // Check complexity - only flag if function is substantial
+                const startLine = path.node.loc?.start.line || 0;
+                const endLine = path.node.loc?.end.line || 0;
+                if (endLine - startLine >= 5) {
+                    // Check if parent is variable declarator (assigned to variable)
+                    const parent = path.parent;
+                    if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id)) {
+                        const loc = path.node.loc;
+                        smells.push({
+                            type: 'ts-missing-return-type',
+                            severity: 'info',
+                            message: `Arrow function "${parent.id.name}" missing return type`,
+                            file: filePath,
+                            line: loc?.start.line || 0,
+                            column: loc?.start.column || 0,
+                            suggestion: 'Add return type: const name = (): ReturnType => { ... }',
+                            codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+                        });
+                    }
+                }
+            }
+        },
+    });
+    // Detect non-null assertion operator (!)
+    component.path.traverse({
+        TSNonNullExpression(path) {
+            const loc = path.node.loc;
+            smells.push({
+                type: 'ts-non-null-assertion',
+                severity: 'warning',
+                message: `Non-null assertion (!) bypasses type safety in "${component.name}"`,
+                file: filePath,
+                line: loc?.start.line || 0,
+                column: loc?.start.column || 0,
+                suggestion: 'Use optional chaining (?.) or proper null checks instead',
+                codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+            });
+        },
+    });
+    // Detect type assertions (as keyword) - these can hide type errors
+    component.path.traverse({
+        TSAsExpression(path) {
+            // Skip assertions to 'const' (used for const assertions)
+            if (t.isTSTypeReference(path.node.typeAnnotation)) {
+                const typeName = path.node.typeAnnotation.typeName;
+                if (t.isIdentifier(typeName) && typeName.name === 'const')
+                    return;
+            }
+            // Skip double assertions (as unknown as Type) - already flagged by TypeScript
+            if (t.isTSAsExpression(path.node.expression))
+                return;
+            const loc = path.node.loc;
+            smells.push({
+                type: 'ts-type-assertion',
+                severity: 'info',
+                message: `Type assertion (as) bypasses type checking in "${component.name}"`,
+                file: filePath,
+                line: loc?.start.line || 0,
+                column: loc?.start.column || 0,
+                suggestion: 'Consider using type guards or proper typing instead of assertions',
+                codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+            });
+        },
+    });
+    return smells;
+}

package/dist/reporter.js

@@ -218,6 +218,30 @@ function formatSmellType(type) {
         'nested-ternary': '❓ Nested Ternary',
         'dead-code': '💀 Dead Code',
         'magic-value': '🔢 Magic Value',
+        // Next.js
+        'nextjs-client-server-boundary': '▲ Next.js Client/Server Boundary',
+        'nextjs-missing-metadata': '▲ Next.js Missing Metadata',
+        'nextjs-image-unoptimized': '▲ Next.js Unoptimized Image',
+        'nextjs-router-misuse': '▲ Next.js Router Misuse',
+        // React Native
+        'rn-inline-style': '📱 RN Inline Style',
+        'rn-missing-accessibility': '📱 RN Missing Accessibility',
+        'rn-performance-issue': '📱 RN Performance Issue',
+        // Node.js
+        'nodejs-callback-hell': '🟢 Node.js Callback Hell',
+        'nodejs-unhandled-promise': '🟢 Node.js Unhandled Promise',
+        'nodejs-sync-io': '🟢 Node.js Sync I/O',
+        'nodejs-missing-error-handling': '🟢 Node.js Missing Error Handling',
+        // JavaScript
+        'js-var-usage': '📜 JS var Usage',
+        'js-loose-equality': '📜 JS Loose Equality',
+        'js-implicit-coercion': '📜 JS Implicit Coercion',
+        'js-global-pollution': '📜 JS Global Pollution',
+        // TypeScript
+        'ts-any-usage': '🔷 TS any Usage',
+        'ts-missing-return-type': '🔷 TS Missing Return Type',
+        'ts-non-null-assertion': '🔷 TS Non-null Assertion',
+        'ts-type-assertion': '🔷 TS Type Assertion',
     };
     return labels[type] || type;
 }

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export type SmellSeverity = 'error' | 'warning' | 'info';
-export type SmellType = 'useEffect-overuse' | 'prop-drilling' | 'large-component' | 'unmemoized-calculation' | 'missing-dependency' | 'state-in-loop' | 'inline-function-prop' | 'deep-nesting' | 'missing-key' | 'hooks-rules-violation' | 'dependency-array-issue' | 'nested-ternary' | 'dead-code' | 'magic-value';
+export type SmellType = 'useEffect-overuse' | 'prop-drilling' | 'large-component' | 'unmemoized-calculation' | 'missing-dependency' | 'state-in-loop' | 'inline-function-prop' | 'deep-nesting' | 'missing-key' | 'hooks-rules-violation' | 'dependency-array-issue' | 'nested-ternary' | 'dead-code' | 'magic-value' | 'nextjs-client-server-boundary' | 'nextjs-missing-metadata' | 'nextjs-image-unoptimized' | 'nextjs-router-misuse' | 'rn-inline-style' | 'rn-missing-accessibility' | 'rn-performance-issue' | 'nodejs-callback-hell' | 'nodejs-unhandled-promise' | 'nodejs-sync-io' | 'nodejs-missing-error-handling' | 'js-var-usage' | 'js-loose-equality' | 'js-implicit-coercion' | 'js-global-pollution' | 'ts-any-usage' | 'ts-missing-return-type' | 'ts-non-null-assertion' | 'ts-type-assertion';
 export interface CodeSmell {
     type: SmellType;
     severity: SmellSeverity;
@@ -66,6 +66,12 @@ export interface DetectorConfig {
     checkDeadCode: boolean;
     checkMagicValues: boolean;
     magicNumberThreshold: number;
+    checkNextjs: boolean;
+    checkReactNative: boolean;
+    checkNodejs: boolean;
+    checkJavascript: boolean;
+    checkTypescript: boolean;
+    maxCallbackDepth: number;
 }
 export declare const DEFAULT_CONFIG: DetectorConfig;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAEzD,MAAM,MAAM,SAAS,GACjB,mBAAmB,GACnB,eAAe,GACf,iBAAiB,GACjB,wBAAwB,GACxB,oBAAoB,GACpB,eAAe,GACf,sBAAsB,GACtB,cAAc,GACd,aAAa,GACb,uBAAuB,GACvB,wBAAwB,GACxB,gBAAgB,GAChB,WAAW,GACX,aAAa,CAAC;AAElB,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,aAAa,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,uBAAuB,EAAE,OAAO,CAAC;CAClC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,kBAAkB,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IACxC,gBAAgB,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IACnC,SAAS,EAAE;QACT,cAAc,EAAE,MAAM,CAAC;QACvB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,kBAAkB,EAAE,MAAM,CAAC;QAC3B,gBAAgB,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,cAAc;IAC7B,yBAAyB,EAAE,MAAM,CAAC;IAClC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,eAAe,EAAE,OAAO,CAAC;IACzB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,eAAO,MAAM,cAAc,EAAE,cAa5B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/dist/types/index.js

@@ -11,4 +11,11 @@ export const DEFAULT_CONFIG = {
     checkDeadCode: true,
     checkMagicValues: true,
     magicNumberThreshold: 10,
+    // Framework detection - auto-enabled based on project
+    checkNextjs: true,
+    checkReactNative: true,
+    checkNodejs: true,
+    checkJavascript: true,
+    checkTypescript: true,
+    maxCallbackDepth: 3,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-code-smell-detector",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Detect code smells in React projects - useEffect overuse, prop drilling, large components, and more",
   "main": "dist/index.js",
   "bin": {

package/src/analyzer.ts

@@ -13,6 +13,11 @@ import {
   detectNestedTernaries,
   detectDeadCode,
   detectMagicValues,
+  detectNextjsIssues,
+  detectReactNativeIssues,
+  detectNodejsIssues,
+  detectJavascriptIssues,
+  detectTypescriptIssues,
 } from './detectors/index.js';
 import {
   AnalysisResult,
@@ -112,6 +117,12 @@ function analyzeFile(parseResult: ParseResult, filePath: string, config: Detecto
     smells.push(...detectNestedTernaries(component, filePath, sourceCode, config));
     smells.push(...detectDeadCode(component, filePath, sourceCode, config));
     smells.push(...detectMagicValues(component, filePath, sourceCode, config));
+    // Framework-specific detectors
+    smells.push(...detectNextjsIssues(component, filePath, sourceCode, config, imports));
+    smells.push(...detectReactNativeIssues(component, filePath, sourceCode, config, imports));
+    smells.push(...detectNodejsIssues(component, filePath, sourceCode, config, imports));
+    smells.push(...detectJavascriptIssues(component, filePath, sourceCode, config));
+    smells.push(...detectTypescriptIssues(component, filePath, sourceCode, config));
   });
 
   // Run cross-component analysis
@@ -141,6 +152,30 @@ function calculateSummary(files: FileAnalysis[]): AnalysisSummary {
     'nested-ternary': 0,
     'dead-code': 0,
     'magic-value': 0,
+    // Next.js
+    'nextjs-client-server-boundary': 0,
+    'nextjs-missing-metadata': 0,
+    'nextjs-image-unoptimized': 0,
+    'nextjs-router-misuse': 0,
+    // React Native
+    'rn-inline-style': 0,
+    'rn-missing-accessibility': 0,
+    'rn-performance-issue': 0,
+    // Node.js
+    'nodejs-callback-hell': 0,
+    'nodejs-unhandled-promise': 0,
+    'nodejs-sync-io': 0,
+    'nodejs-missing-error-handling': 0,
+    // JavaScript
+    'js-var-usage': 0,
+    'js-loose-equality': 0,
+    'js-implicit-coercion': 0,
+    'js-global-pollution': 0,
+    // TypeScript
+    'ts-any-usage': 0,
+    'ts-missing-return-type': 0,
+    'ts-non-null-assertion': 0,
+    'ts-type-assertion': 0,
   };
 
   const smellsBySeverity: Record<SmellSeverity, number> = {

package/src/detectors/index.ts

@@ -8,3 +8,9 @@ export { detectDependencyArrayIssues } from './dependencyArray.js';
 export { detectNestedTernaries } from './nestedTernary.js';
 export { detectDeadCode, detectUnusedImports } from './deadCode.js';
 export { detectMagicValues } from './magicValues.js';
+// Framework-specific detectors
+export { detectNextjsIssues } from './nextjs.js';
+export { detectReactNativeIssues } from './reactNative.js';
+export { detectNodejsIssues } from './nodejs.js';
+export { detectJavascriptIssues } from './javascript.js';
+export { detectTypescriptIssues } from './typescript.js';

package/src/detectors/javascript.ts

@@ -0,0 +1,169 @@
+import * as t from '@babel/types';
+import { ParsedComponent, getCodeSnippet } from '../parser/index.js';
+import { CodeSmell, DetectorConfig, DEFAULT_CONFIG } from '../types/index.js';
+
+/**
+ * Detects vanilla JavaScript code smells:
+ * - var usage (should use let/const)
+ * - Loose equality (== instead of ===)
+ * - Implicit type coercion
+ * - Global variable pollution
+ */
+export function detectJavascriptIssues(
+  component: ParsedComponent,
+  filePath: string,
+  sourceCode: string,
+  config: DetectorConfig = DEFAULT_CONFIG
+): CodeSmell[] {
+  if (!config.checkJavascript) return [];
+
+  const smells: CodeSmell[] = [];
+
+  // Detect var usage (should use let/const)
+  component.path.traverse({
+    VariableDeclaration(path) {
+      if (path.node.kind === 'var') {
+        const loc = path.node.loc;
+        smells.push({
+          type: 'js-var-usage',
+          severity: 'warning',
+          message: `Using "var" instead of "let" or "const" in "${component.name}"`,
+          file: filePath,
+          line: loc?.start.line || 0,
+          column: loc?.start.column || 0,
+          suggestion: 'Use "const" for values that never change, "let" for reassignable variables',
+          codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+        });
+      }
+    },
+  });
+
+  // Detect loose equality (== and != instead of === and !==)
+  component.path.traverse({
+    BinaryExpression(path) {
+      const { operator, left, right } = path.node;
+      
+      // Skip if comparing with null/undefined (sometimes intentional)
+      const isNullCheck = 
+        (t.isNullLiteral(left) || t.isNullLiteral(right)) ||
+        (t.isIdentifier(left) && left.name === 'undefined') ||
+        (t.isIdentifier(right) && right.name === 'undefined');
+      
+      if (operator === '==' && !isNullCheck) {
+        const loc = path.node.loc;
+        smells.push({
+          type: 'js-loose-equality',
+          severity: 'warning',
+          message: `Using loose equality "==" in "${component.name}"`,
+          file: filePath,
+          line: loc?.start.line || 0,
+          column: loc?.start.column || 0,
+          suggestion: 'Use strict equality "===" to avoid type coercion bugs',
+          codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+        });
+      }
+      
+      if (operator === '!=' && !isNullCheck) {
+        const loc = path.node.loc;
+        smells.push({
+          type: 'js-loose-equality',
+          severity: 'warning',
+          message: `Using loose inequality "!=" in "${component.name}"`,
+          file: filePath,
+          line: loc?.start.line || 0,
+          column: loc?.start.column || 0,
+          suggestion: 'Use strict inequality "!==" to avoid type coercion bugs',
+          codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+        });
+      }
+    },
+  });
+
+  // Detect implicit type coercion patterns
+  component.path.traverse({
+    // +string to convert to number
+    UnaryExpression(path) {
+      if (path.node.operator === '+' && t.isIdentifier(path.node.argument)) {
+        const loc = path.node.loc;
+        smells.push({
+          type: 'js-implicit-coercion',
+          severity: 'info',
+          message: `Implicit number coercion with unary + in "${component.name}"`,
+          file: filePath,
+          line: loc?.start.line || 0,
+          column: loc?.start.column || 0,
+          suggestion: 'Use explicit conversion: Number(value) or parseInt(value, 10)',
+          codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+        });
+      }
+    },
+    
+    // !!value for boolean coercion - detected via UnaryExpression
+    // LogicalExpression handles &&, ||, ?? - skip for !! detection
+    
+    // String concatenation with + that mixes types
+    BinaryExpression(path) {
+      if (path.node.operator === '+') {
+        const { left, right } = path.node;
+        const leftIsString = t.isStringLiteral(left) || t.isTemplateLiteral(left);
+        const rightIsString = t.isStringLiteral(right) || t.isTemplateLiteral(right);
+        const leftIsNumber = t.isNumericLiteral(left);
+        const rightIsNumber = t.isNumericLiteral(right);
+        
+        // Mixed string + number concatenation
+        if ((leftIsString && rightIsNumber) || (leftIsNumber && rightIsString)) {
+          const loc = path.node.loc;
+          smells.push({
+            type: 'js-implicit-coercion',
+            severity: 'info',
+            message: `Implicit string coercion in "${component.name}"`,
+            file: filePath,
+            line: loc?.start.line || 0,
+            column: loc?.start.column || 0,
+            suggestion: 'Use template literal for clarity: `${value}` or String(value)',
+            codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+          });
+        }
+      }
+    },
+  });
+
+  // Detect potential global pollution (assignments without declaration)
+  component.path.traverse({
+    AssignmentExpression(path) {
+      const { left } = path.node;
+      
+      if (t.isIdentifier(left)) {
+        // Check if this identifier is declared in scope
+        const binding = path.scope.getBinding(left.name);
+        
+        if (!binding) {
+          // Check if it's a well-known global
+          const knownGlobals = [
+            'window', 'document', 'console', 'localStorage', 'sessionStorage',
+            'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
+            'fetch', 'XMLHttpRequest', 'WebSocket', 'module', 'exports',
+            'require', 'process', 'global', '__dirname', '__filename',
+            'Buffer', 'Promise', 'Map', 'Set', 'Symbol',
+          ];
+          
+          if (!knownGlobals.includes(left.name)) {
+            const loc = path.node.loc;
+            smells.push({
+              type: 'js-global-pollution',
+              severity: 'error',
+              message: `Implicit global variable "${left.name}" in "${component.name}"`,
+              file: filePath,
+              line: loc?.start.line || 0,
+              column: loc?.start.column || 0,
+              suggestion: `Declare the variable: const ${left.name} = ... or let ${left.name} = ...`,
+              codeSnippet: getCodeSnippet(sourceCode, loc?.start.line || 0),
+            });
+          }
+        }
+      }
+    },
+  });
+
+  return smells;
+}