eslint-plugin-code-style 1.5.1 → 1.5.2

package/index.js

@@ -1809,10 +1809,26 @@ const functionDeclarationStyle = {
                 }
 
                 // Build type parameters if present (generics)
+                // For arrow functions in TSX files, use trailing comma to avoid JSX ambiguity: <T,>
                 let typeParams = "";
 
                 if (node.typeParameters) {
-                    typeParams = sourceCode.getText(node.typeParameters);
+                    const typeParamsText = sourceCode.getText(node.typeParameters);
+
+                    // Add trailing comma if single type parameter to avoid JSX parsing issues
+                    // <T> becomes <T,> but <T, U> stays as is
+                    if (node.typeParameters.params && node.typeParameters.params.length === 1) {
+                        // Check if it already has a trailing comma
+                        const innerText = typeParamsText.slice(1, -1).trim();
+
+                        if (!innerText.endsWith(",")) {
+                            typeParams = `<${innerText},>`;
+                        } else {
+                            typeParams = typeParamsText;
+                        }
+                    } else {
+                        typeParams = typeParamsText;
+                    }
                 }
 
                 // Check if async
@@ -1832,11 +1848,12 @@ const functionDeclarationStyle = {
                     fix(fixer) {
                         const fixTarget = isExported ? parentNode : node;
 
-                        const replacement = `${exportPrefix}const ${name} = ${asyncPrefix}(${paramsText})${returnType} => ${bodyText};`;
+                        // For arrow functions with generics: const fn = <T,>(param: T) => ...
+                        const replacement = `${exportPrefix}const ${name} = ${typeParams}${asyncPrefix}(${paramsText})${returnType} => ${bodyText};`;
 
                         return fixer.replaceText(fixTarget, replacement);
                     },
-                    message: `Expected a function expression. Use \`const ${name} = ${asyncPrefix}(${paramsText})${returnType} => ...\` instead.`,
+                    message: `Expected a function expression. Use \`const ${name} = ${typeParams}${asyncPrefix}(${paramsText})${returnType} => ...\` instead.`,
                     node: node.id,
                 });
             },
@@ -2184,17 +2201,23 @@ const functionNamingConvention = {
                         const classBody = node.parent;
 
                         if (classBody && classBody.type === "ClassBody") {
-                            const sourceCode = context.sourceCode || context.getSourceCode();
-                            const classText = sourceCode.getText(classBody);
-
                             // Find usages like this.methodName or super.methodName
                             const classNode = classBody.parent;
 
                             if (classNode) {
+                                const visited = new Set();
+
                                 const searchPatternHandler = (n) => {
+                                    // Avoid circular references and already visited nodes
+                                    if (!n || typeof n !== "object" || visited.has(n)) return;
+
+                                    visited.add(n);
+
                                     if (n.type === "MemberExpression" &&
+                                        n.property &&
                                         n.property.type === "Identifier" &&
                                         n.property.name === name &&
+                                        n.object &&
                                         (n.object.type === "ThisExpression" || n.object.type === "Super")) {
                                         // Don't fix the definition itself
                                         if (n.property !== key) {
@@ -2202,18 +2225,19 @@ const functionNamingConvention = {
                                         }
                                     }
 
-                                    // Recursively search
-                                    for (const childKey of Object.keys(n)) {
+                                    // Recursively search only AST child properties (skip parent, tokens, etc.)
+                                    const childKeys = ["body", "declarations", "expression", "left", "right",
+                                        "callee", "arguments", "object", "property", "consequent", "alternate",
+                                        "test", "init", "update", "params", "elements", "properties", "value",
+                                        "key", "argument", "block", "handler", "finalizer", "cases"];
+
+                                    for (const childKey of childKeys) {
                                         const child = n[childKey];
 
-                                        if (child && typeof child === "object") {
+                                        if (child) {
                                             if (Array.isArray(child)) {
-                                                child.forEach((item) => {
-                                                    if (item && typeof item === "object" && item.type) {
-                                                        searchPatternHandler(item);
-                                                    }
-                                                });
-                                            } else if (child.type) {
+                                                child.forEach((item) => searchPatternHandler(item));
+                                            } else {
                                                 searchPatternHandler(child);
                                             }
                                         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-code-style",
-    "version": "1.5.1",
+    "version": "1.5.2",
     "description": "A custom ESLint plugin for enforcing consistent code formatting and style rules in React/JSX projects",
     "main": "index.js",
     "types": "index.d.ts",