eslint-plugin-code-style 1.7.1 → 1.7.2

package/CHANGELOG.md

@@ -7,14 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.7.2] - 2026-02-02
+
+### Fixed
+
+- **`enum-format`** - Fix double comma bug when auto-fixing trailing comma and closing brace position; check for comma token after member, not just member text
+- **`interface-format`** - Same fix as enum-format for trailing comma detection
+
+---
+
 ## [1.7.1] - 2026-02-02
 
 ### Fixed
 
 - **`no-empty-lines-in-function-params`** - Detect empty lines between destructured properties inside ObjectPattern params
 - **`component-props-inline-type`** - Handle TSIntersectionType (e.g., `ButtonHTMLAttributes & { prop: Type }`): check `&` position, opening brace position, and apply formatting rules to type literals within intersections
-- **`enum-type-enforcement`** - Fix argument passed to extractTypeInfoHandler for TSPropertySignature members (was passing `member`, now correctly passes `member.typeAnnotation`)
-- **`ternary-condition-multiline`** - Improve simple ternary prefix calculation to use actual declaration text instead of column positions; add check for `?` on same line as multiline condition end
+- **`enum-type-enforcement`** - Handle TSIntersectionType to track typed props; fix extractTypeInfoHandler argument for TSPropertySignature members
+- **`ternary-condition-multiline`** - Improve simple ternary prefix calculation for object properties; add checks for `?` on same line as condition end and empty lines before `?` or `:`; fix multiline formatting to not add leading newline
 
 ---
 
@@ -1075,6 +1084,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[1.7.2]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.7.1...v1.7.2
 [1.7.1]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.7.0...v1.7.1
 [1.7.0]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.6...v1.7.0
 [1.6.6]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.5...v1.6.6

package/index.js

@@ -4049,7 +4049,7 @@ const ternaryConditionMultiline = {
             const singleLineText = getTernarySingleLineHandler(node);
             const indent = getLineIndentHandler(node);
 
-            // Check if the parent needs prefix text (like "const x = ")
+            // Check if the parent needs prefix text (like "const x = " or "key: ")
             let prefixLength = 0;
             const parent = node.parent;
 
@@ -4066,6 +4066,11 @@ const ternaryConditionMultiline = {
                 const leftText = sourceCode.getText(parent.left);
 
                 prefixLength = leftText.length + 3; // left + " = "
+            } else if (parent && parent.type === "Property" && parent.value === node) {
+                // Object property: key: ternary
+                const keyText = sourceCode.getText(parent.key);
+
+                prefixLength = keyText.length + 2; // key + ": "
             }
 
             // Check if single line would fit
@@ -4155,6 +4160,24 @@ const ternaryConditionMultiline = {
                         isCorrectionNeeded = true;
                     }
                 }
+
+                // Check for empty lines before ? (between condition and ?)
+                if (!isCorrectionNeeded) {
+                    const questionToken = sourceCode.getTokenAfter(test, (t) => t.value === "?");
+
+                    if (questionToken && questionToken.loc.start.line > test.loc.end.line + 1) {
+                        isCorrectionNeeded = true;
+                    }
+                }
+
+                // Check for empty lines before : (between consequent and :)
+                if (!isCorrectionNeeded) {
+                    const colonToken = sourceCode.getTokenAfter(node.consequent, (t) => t.value === ":");
+
+                    if (colonToken && colonToken.loc.start.line > node.consequent.loc.end.line + 1) {
+                        isCorrectionNeeded = true;
+                    }
+                }
             }
 
             if (isCorrectionNeeded) {
@@ -4164,7 +4187,6 @@ const ternaryConditionMultiline = {
                         const lineText = sourceCode.lines[node.loc.start.line - 1];
                         const baseIndent = lineText.match(/^\s*/)[0];
                         const conditionIndent = baseIndent + "    ";
-                        const branchIndent = baseIndent + "        ";
 
                         const buildMultilineHandler = (n) => {
                             if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
@@ -4180,7 +4202,9 @@ const ternaryConditionMultiline = {
                         const consequentText = sourceCode.getText(node.consequent);
                         const alternateText = sourceCode.getText(node.alternate);
 
-                        const newText = `\n${conditionIndent}${buildMultilineHandler(test)}\n${branchIndent}? ${consequentText}\n${branchIndent}: ${alternateText}`;
+                        // No leading newline - keep first operand on same line as whatever precedes it
+                        // Use conditionIndent for ? and : to align with || operators
+                        const newText = `${buildMultilineHandler(test)}\n${conditionIndent}? ${consequentText}\n${conditionIndent}: ${alternateText}`;
 
                         return fixer.replaceText(node, newText);
                     },
@@ -4481,6 +4505,20 @@ const enumTypeEnforcement = {
             return null;
         };
 
+        // Helper to process TSTypeLiteral members
+        const processTypeLiteralMembersHandler = (members) => {
+            members.forEach((member) => {
+                if (member.type === "TSPropertySignature" && member.key?.type === "Identifier") {
+                    const propName = member.key.name;
+                    const typeInfo = extractTypeInfoHandler(member.typeAnnotation);
+
+                    if (typeInfo) {
+                        typeAnnotatedVars.set(propName, typeInfo);
+                    }
+                }
+            });
+        };
+
         // Track type-annotated parameters in function/component definitions
         const trackTypedParamsHandler = (params) => {
             params.forEach((param) => {
@@ -4489,14 +4527,14 @@ const enumTypeEnforcement = {
                     const annotation = param.typeAnnotation.typeAnnotation;
 
                     if (annotation && annotation.type === "TSTypeLiteral") {
-                        annotation.members.forEach((member) => {
-                            if (member.type === "TSPropertySignature" && member.key?.type === "Identifier") {
-                                const propName = member.key.name;
-                                const typeInfo = extractTypeInfoHandler(member.typeAnnotation);
+                        processTypeLiteralMembersHandler(annotation.members);
+                    }
 
-                                if (typeInfo) {
-                                    typeAnnotatedVars.set(propName, typeInfo);
-                                }
+                    // Handle intersection types: ButtonHTMLAttributes<HTMLButtonElement> & { variant?: ButtonVariantType }
+                    if (annotation && annotation.type === "TSIntersectionType") {
+                        annotation.types.forEach((intersectionType) => {
+                            if (intersectionType.type === "TSTypeLiteral") {
+                                processTypeLiteralMembersHandler(intersectionType.members);
                             }
                         });
                     }
@@ -14412,6 +14450,36 @@ const componentPropsInlineType = {
                             }
                         }
                     });
+
+                    // Check that last member has trailing comma
+                    if (members.length > 0) {
+                        const lastMember = members[members.length - 1];
+                        const lastMemberText = sourceCode.getText(lastMember);
+
+                        if (!lastMemberText.trimEnd().endsWith(",")) {
+                            context.report({
+                                fix: (fixer) => fixer.insertTextAfter(lastMember, ","),
+                                message: "Last props type property must have trailing comma",
+                                node: lastMember,
+                            });
+                        }
+                    }
+
+                    // Check for empty lines before closing brace
+                    if (members.length > 0 && closeBraceToken) {
+                        const lastMember = members[members.length - 1];
+
+                        if (closeBraceToken.loc.start.line - lastMember.loc.end.line > 1) {
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange(
+                                    [lastMember.range[1], closeBraceToken.range[0]],
+                                    "\n" + baseIndent,
+                                ),
+                                message: "No empty line before closing brace in props type",
+                                node: closeBraceToken,
+                            });
+                        }
+                    }
                 }
 
                 return;
@@ -14619,6 +14687,20 @@ const componentPropsInlineType = {
                         }
                     }
                 });
+
+                // Check that last member has trailing comma
+                if (members.length > 0) {
+                    const lastMember = members[members.length - 1];
+                    const lastMemberText = sourceCode.getText(lastMember);
+
+                    if (!lastMemberText.trimEnd().endsWith(",")) {
+                        context.report({
+                            fix: (fixer) => fixer.insertTextAfter(lastMember, ","),
+                            message: "Last props type property must have trailing comma",
+                            node: lastMember,
+                        });
+                    }
+                }
             }
         };
 
@@ -16956,19 +17038,24 @@ const enumFormat = {
                     }
 
                     // Check member ends with comma, not semicolon
-                    const memberText = sourceCode.getText(member);
+                    // Skip last member when multiple members - handled by combined check below
+                    const isLastMember = index === members.length - 1;
 
-                    if (memberText.trimEnd().endsWith(";")) {
-                        context.report({
-                            fix(fixer) {
-                                const lastChar = memberText.lastIndexOf(";");
-                                const absolutePos = member.range[0] + lastChar;
+                    if (!isLastMember || members.length === 1) {
+                        const memberText = sourceCode.getText(member);
 
-                                return fixer.replaceTextRange([absolutePos, absolutePos + 1], ",");
-                            },
-                            message: "Enum members must end with comma (,) not semicolon (;)",
-                            node: member,
-                        });
+                        if (memberText.trimEnd().endsWith(";")) {
+                            context.report({
+                                fix(fixer) {
+                                    const lastChar = memberText.lastIndexOf(";");
+                                    const absolutePos = member.range[0] + lastChar;
+
+                                    return fixer.replaceTextRange([absolutePos, absolutePos + 1], ",");
+                                },
+                                message: "Enum members must end with comma (,) not semicolon (;)",
+                                node: member,
+                            });
+                        }
                     }
 
                     // Check formatting for multiple members
@@ -17018,6 +17105,67 @@ const enumFormat = {
                         }
                     }
                 });
+
+                // Check closing brace position and trailing comma/semicolon (for multiple members)
+                if (members.length > 1) {
+                    const lastMemberText = sourceCode.getText(lastMember);
+                    const trimmedText = lastMemberText.trimEnd();
+                    // Check both: text ends with comma OR there's a comma token after the member
+                    const tokenAfterLast = sourceCode.getTokenAfter(lastMember);
+                    const hasTrailingComma = trimmedText.endsWith(",") || (tokenAfterLast && tokenAfterLast.value === ",");
+                    const hasTrailingSemicolon = trimmedText.endsWith(";");
+                    const braceOnSameLine = closeBraceToken && closeBraceToken.loc.start.line === lastMember.loc.end.line;
+
+                    // Handle semicolon on last member (needs replacement with comma)
+                    if (hasTrailingSemicolon) {
+                        const lastSemicolon = lastMemberText.lastIndexOf(";");
+                        const absolutePos = lastMember.range[0] + lastSemicolon;
+
+                        if (braceOnSameLine) {
+                            // Both semicolon and brace issues - fix together
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange(
+                                    [absolutePos, closeBraceToken.range[0]],
+                                    ",\n" + baseIndent,
+                                ),
+                                message: "Last enum member must end with comma and closing brace must be on its own line",
+                                node: lastMember,
+                            });
+                        } else {
+                            // Just semicolon issue
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange([absolutePos, absolutePos + 1], ","),
+                                message: "Enum members must end with comma (,) not semicolon (;)",
+                                node: lastMember,
+                            });
+                        }
+                    } else if (!hasTrailingComma && braceOnSameLine) {
+                        // Both missing comma and brace issues - fix together
+                        context.report({
+                            fix: (fixer) => fixer.replaceTextRange(
+                                [lastMember.range[1], closeBraceToken.range[0]],
+                                ",\n" + baseIndent,
+                            ),
+                            message: "Last enum member must have trailing comma and closing brace must be on its own line",
+                            node: lastMember,
+                        });
+                    } else if (!hasTrailingComma) {
+                        context.report({
+                            fix: (fixer) => fixer.insertTextAfter(lastMember, ","),
+                            message: "Last enum member must have trailing comma",
+                            node: lastMember,
+                        });
+                    } else if (braceOnSameLine) {
+                        context.report({
+                            fix: (fixer) => fixer.replaceTextRange(
+                                [lastMember.range[1], closeBraceToken.range[0]],
+                                "\n" + baseIndent,
+                            ),
+                            message: "Closing brace must be on its own line",
+                            node: closeBraceToken,
+                        });
+                    }
+                }
             },
         };
     },
@@ -17201,19 +17349,24 @@ const interfaceFormat = {
                     }
 
                     // Check property ends with comma, not semicolon
-                    const memberText = sourceCode.getText(member);
+                    // Skip last member when multiple members - handled by combined check below
+                    const isLastMember = index === members.length - 1;
 
-                    if (memberText.trimEnd().endsWith(";")) {
-                        context.report({
-                            fix(fixer) {
-                                const lastChar = memberText.lastIndexOf(";");
-                                const absolutePos = member.range[0] + lastChar;
+                    if (!isLastMember || members.length === 1) {
+                        const memberText = sourceCode.getText(member);
 
-                                return fixer.replaceTextRange([absolutePos, absolutePos + 1], ",");
-                            },
-                            message: "Interface properties must end with comma (,) not semicolon (;)",
-                            node: member,
-                        });
+                        if (memberText.trimEnd().endsWith(";")) {
+                            context.report({
+                                fix(fixer) {
+                                    const lastChar = memberText.lastIndexOf(";");
+                                    const absolutePos = member.range[0] + lastChar;
+
+                                    return fixer.replaceTextRange([absolutePos, absolutePos + 1], ",");
+                                },
+                                message: "Interface properties must end with comma (,) not semicolon (;)",
+                                node: member,
+                            });
+                        }
                     }
 
                     // Check formatting for multiple members
@@ -17263,6 +17416,67 @@ const interfaceFormat = {
                         }
                     }
                 });
+
+                // Check closing brace position and trailing comma/semicolon (for multiple members)
+                if (members.length > 1) {
+                    const lastMemberText = sourceCode.getText(lastMember);
+                    const trimmedText = lastMemberText.trimEnd();
+                    // Check both: text ends with comma OR there's a comma token after the member
+                    const tokenAfterLast = sourceCode.getTokenAfter(lastMember);
+                    const hasTrailingComma = trimmedText.endsWith(",") || (tokenAfterLast && tokenAfterLast.value === ",");
+                    const hasTrailingSemicolon = trimmedText.endsWith(";");
+                    const braceOnSameLine = closeBraceToken.loc.start.line === lastMember.loc.end.line;
+
+                    // Handle semicolon on last member (needs replacement with comma)
+                    if (hasTrailingSemicolon) {
+                        const lastSemicolon = lastMemberText.lastIndexOf(";");
+                        const absolutePos = lastMember.range[0] + lastSemicolon;
+
+                        if (braceOnSameLine) {
+                            // Both semicolon and brace issues - fix together
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange(
+                                    [absolutePos, closeBraceToken.range[0]],
+                                    ",\n" + baseIndent,
+                                ),
+                                message: "Last interface property must end with comma and closing brace must be on its own line",
+                                node: lastMember,
+                            });
+                        } else {
+                            // Just semicolon issue
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange([absolutePos, absolutePos + 1], ","),
+                                message: "Interface properties must end with comma (,) not semicolon (;)",
+                                node: lastMember,
+                            });
+                        }
+                    } else if (!hasTrailingComma && braceOnSameLine) {
+                        // Both missing comma and brace issues - fix together
+                        context.report({
+                            fix: (fixer) => fixer.replaceTextRange(
+                                [lastMember.range[1], closeBraceToken.range[0]],
+                                ",\n" + baseIndent,
+                            ),
+                            message: "Last interface property must have trailing comma and closing brace must be on its own line",
+                            node: lastMember,
+                        });
+                    } else if (!hasTrailingComma) {
+                        context.report({
+                            fix: (fixer) => fixer.insertTextAfter(lastMember, ","),
+                            message: "Last interface property must have trailing comma",
+                            node: lastMember,
+                        });
+                    } else if (braceOnSameLine) {
+                        context.report({
+                            fix: (fixer) => fixer.replaceTextRange(
+                                [lastMember.range[1], closeBraceToken.range[0]],
+                                "\n" + baseIndent,
+                            ),
+                            message: "Closing brace must be on its own line",
+                            node: closeBraceToken,
+                        });
+                    }
+                }
             },
         };
     },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-code-style",
-    "version": "1.7.1",
+    "version": "1.7.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",