eslint-plugin-code-style 1.7.2 → 1.7.3

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.7.3] - 2026-02-02
+
+### Fixed
+
+- **`ternary-condition-multiline`** - Fix `?`/`:` on own line without value; collapse simple ternaries to single line when they fit
+- **`no-empty-lines-in-function-params`** - Detect empty lines after opening `{` and before closing `}` in ObjectPattern params
+- **`empty-line-after-block`** - Skip consecutive if statements (already handled by `if-else-spacing`)
+- **`classname-multiline`** - Fix closing backtick alignment for return statements
+
+### Documentation
+
+- Add 6 missing rules to README detailed documentation
+- Add 7 missing rules to README Quick Start example
+- Update rule counts from 66 to 69 across all documentation files
+- Update AGENTS.md Tailwind section with actual rules and comparison with `tailwindcss/classnames-order`
+- Add README multi-section update warnings to AGENTS.md rule modification checklists
+
+### Added
+
+- **`manage-rule` skill** - New skill for adding, editing, or removing ESLint rules with complete workflow
+
+---
+
 ## [1.7.2] - 2026-02-02
 
 ### Fixed

package/README.md

@@ -190,14 +190,18 @@ rules: {
     "code-style/arrow-function-simplify": "error",
     "code-style/assignment-value-same-line": "error",
     "code-style/block-statement-newlines": "error",
+    "code-style/class-naming-convention": "error",
     "code-style/classname-dynamic-at-end": "error",
     "code-style/classname-multiline": "error",
     "code-style/classname-no-extra-spaces": "error",
+    "code-style/classname-order": "error",
     "code-style/comment-format": "error",
     "code-style/component-props-destructure": "error",
     "code-style/component-props-inline-type": "error",
     "code-style/curried-arrow-same-line": "error",
+    "code-style/empty-line-after-block": "error",
     "code-style/enum-format": "error",
+    "code-style/enum-type-enforcement": "error",
     "code-style/export-format": "error",
     "code-style/function-arguments-format": "error",
     "code-style/function-call-spacing": "error",
@@ -212,6 +216,7 @@ rules: {
     "code-style/import-format": "error",
     "code-style/import-source-spacing": "error",
     "code-style/index-export-style": "error",
+    "code-style/index-exports-only": "error",
     "code-style/interface-format": "error",
     "code-style/jsx-children-on-new-line": "error",
     "code-style/jsx-closing-bracket-spacing": "error",
@@ -231,6 +236,7 @@ rules: {
     "code-style/no-empty-lines-in-jsx": "error",
     "code-style/no-empty-lines-in-objects": "error",
     "code-style/no-empty-lines-in-switch-cases": "error",
+    "code-style/no-inline-type-definitions": "error",
     "code-style/object-property-per-line": "error",
     "code-style/object-property-value-brace": "error",
     "code-style/object-property-value-format": "error",
@@ -239,6 +245,7 @@ rules: {
     "code-style/simple-call-single-line": "error",
     "code-style/single-argument-on-one-line": "error",
     "code-style/string-property-spacing": "error",
+    "code-style/ternary-condition-multiline": "error",
     "code-style/type-annotation-spacing": "error",
     "code-style/type-format": "error",
     "code-style/typescript-definition-location": "error",
@@ -881,6 +888,37 @@ dispatch(
 
 <br />
 
+## 🏛️ Class Rules
+
+### `class-naming-convention`
+
+**What it does:** Enforces that class declarations must end with "Class" suffix. This distinguishes class definitions from other PascalCase names like React components or type definitions.
+
+**Why use it:** Clear naming conventions prevent confusion between classes, components, and types. The "Class" suffix immediately identifies the construct.
+
+```javascript
+// ✅ Good — class ends with "Class"
+class ApiServiceClass {
+    constructor() {}
+    fetch() {}
+}
+
+class UserRepositoryClass {
+    save(user) {}
+}
+
+// ❌ Bad — missing "Class" suffix
+class ApiService {
+    constructor() {}
+}
+
+class UserRepository {
+    save(user) {}
+}
+```
+
+<br />
+
 ## 🔀 Control Flow Rules
 
 ### `block-statement-newlines`
@@ -916,6 +954,38 @@ for (const item of items) { process(item);
 
 ---
 
+### `empty-line-after-block`
+
+**What it does:** Requires an empty line between a closing brace `}` of a block statement (if, try, for, while, etc.) and the next statement, unless the next statement is part of the same construct (else, catch, finally).
+
+**Why use it:** Visual separation between logical blocks improves code readability and makes the structure clearer.
+
+> **Note:** Consecutive if statements are handled by `if-else-spacing` rule.
+
+```javascript
+// ✅ Good — empty line after block
+if (condition) {
+    doSomething();
+}
+
+const x = 1;
+
+// ✅ Good — else is part of same construct (no empty line needed)
+if (condition) {
+    doSomething();
+} else {
+    doOther();
+}
+
+// ❌ Bad — no empty line after block
+if (condition) {
+    doSomething();
+}
+const x = 1;
+```
+
+---
+
 ### `if-else-spacing`
 
 **What it does:** Enforces proper spacing between if statements and if-else chains:
@@ -1137,6 +1207,39 @@ switch (status) {
 }
 ```
 
+---
+
+### `ternary-condition-multiline`
+
+**What it does:** Enforces consistent ternary formatting:
+- Simple ternaries (≤3 operands in condition) collapse to single line if they fit
+- Complex ternaries (>3 operands) expand to multiline with each operand on its own line
+
+**Why use it:** Long ternary conditions on a single line are hard to read. Breaking complex conditions into multiple lines makes them scannable.
+
+**Options:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `maxOperands` | `integer` | `3` | Maximum operands to keep on single line |
+| `maxLineLength` | `integer` | `120` | Maximum line length for single-line ternaries |
+
+```javascript
+// ✅ Good — simple condition on single line
+const x = a && b && c ? "yes" : "no";
+
+// ✅ Good — complex condition multiline (>3 operands)
+const style = variant === "ghost"
+    || variant === "ghost-danger"
+    || variant === "muted"
+    || variant === "primary"
+    ? "transparent"
+    : "solid";
+
+// ❌ Bad — complex condition crammed on one line
+const style = variant === "ghost" || variant === "ghost-danger" || variant === "muted" || variant === "primary" ? "transparent" : "solid";
+```
+
 <br />
 
 ## ⚡ Function Rules
@@ -1719,6 +1822,28 @@ export {
 
 ---
 
+### `index-exports-only`
+
+**What it does:** Index files (`index.ts`, `index.tsx`, `index.js`, `index.jsx`) should only contain imports and re-exports, not any code definitions. All definitions (types, interfaces, functions, variables, classes) should be moved to separate files.
+
+**Why use it:** Index files should be "barrels" that aggregate exports from a module. Mixing definitions with re-exports makes the codebase harder to navigate and can cause circular dependency issues.
+
+```javascript
+// ✅ Good — index.ts with only imports and re-exports
+export { Button } from "./Button";
+export { helper } from "./utils";
+export type { ButtonProps } from "./types";
+export * from "./constants";
+
+// ❌ Bad — index.ts with code definitions
+export type ButtonVariant = "primary" | "secondary";  // Move to types.ts
+export interface ButtonProps { ... }                  // Move to types.ts
+export const CONSTANT = "value";                      // Move to constants.ts
+export function helper() { ... }                      // Move to utils.ts
+```
+
+---
+
 ### `module-index-exports`
 
 **What it does:** Ensures module folders have index files that export all their contents, creating a proper public API for each module.
@@ -1897,6 +2022,49 @@ const buttonClasses = ` flex items-center ${className} `;
 
 ---
 
+### `classname-order`
+
+**What it does:** Enforces Tailwind CSS class ordering in variables, object properties, and return statements. Uses smart detection to identify Tailwind class strings.
+
+**Why use it:** This rule complements the official `tailwindcss/classnames-order` plugin by handling areas it doesn't cover:
+- **`tailwindcss/classnames-order`** — Handles JSX `className` attributes directly
+- **`classname-order`** — Handles class strings in variables, object properties, and return statements
+
+Both rules should be enabled together for complete Tailwind class ordering coverage.
+
+**Order enforced:** layout (flex, grid) → positioning → sizing (w, h) → spacing (p, m) → typography (text, font) → colors (bg, text) → effects (shadow, opacity) → transitions → states (hover, focus)
+
+```javascript
+// ✅ Good — classes in correct order (variable)
+const buttonClasses = "flex items-center px-4 py-2 text-white bg-blue-500 hover:bg-blue-600";
+
+// ✅ Good — classes in correct order (object property)
+const variants = {
+    primary: "flex items-center bg-blue-500 hover:bg-blue-600",
+    secondary: "flex items-center bg-gray-500 hover:bg-gray-600",
+};
+
+// ✅ Good — classes in correct order (return statement)
+const getInputStyles = () => {
+    return "border-error text-error placeholder-error/50 focus:border-error";
+};
+
+// ❌ Bad — hover state before base color (variable)
+const buttonClasses = "flex items-center hover:bg-blue-600 bg-blue-500";
+
+// ❌ Bad — unordered classes (object property)
+const variants = {
+    primary: "hover:bg-blue-600 bg-blue-500 flex items-center",
+};
+
+// ❌ Bad — unordered classes (return statement)
+const getInputStyles = () => {
+    return "focus:border-error text-error border-error";
+};
+```
+
+---
+
 ### `jsx-children-on-new-line`
 
 **What it does:** When a JSX element has multiple children, ensures each child is on its own line with proper indentation.
@@ -2696,6 +2864,38 @@ export enum UserStatusEnum {
 
 ---
 
+### `enum-type-enforcement`
+
+**What it does:** When a variable or parameter has a type ending in `Type` (like `ButtonVariantType`), enforces using the corresponding enum (`ButtonVariantEnum.VALUE`) instead of string literals.
+
+**Why use it:** Using enum values instead of string literals provides type safety, autocompletion, and prevents typos. Changes to enum values automatically propagate.
+
+```javascript
+// ✅ Good — using enum values
+const Button = ({
+    variant = ButtonVariantEnum.PRIMARY,
+}: {
+    variant?: ButtonVariantType,
+}) => { ... };
+
+if (variant === ButtonVariantEnum.GHOST) {
+    // ...
+}
+
+// ❌ Bad — using string literals
+const Button = ({
+    variant = "primary",  // Should use ButtonVariantEnum.PRIMARY
+}: {
+    variant?: ButtonVariantType,
+}) => { ... };
+
+if (variant === "ghost") {  // Should use ButtonVariantEnum.GHOST
+    // ...
+}
+```
+
+---
+
 ### `interface-format`
 
 **What it does:** Enforces consistent formatting for TypeScript interfaces:
@@ -2739,6 +2939,42 @@ export interface UserInterface {
 
 ---
 
+### `no-inline-type-definitions`
+
+**What it does:** Reports when function parameters have inline union types that are too complex (too many members or too long). These should be extracted to a named type in a types file.
+
+**Why use it:** Complex inline types make function signatures hard to read. Named types are reusable, self-documenting, and easier to maintain.
+
+**Options:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `maxUnionMembers` | `integer` | `2` | Maximum union members before requiring extraction |
+| `maxLength` | `integer` | `50` | Maximum character length before requiring extraction |
+
+```javascript
+// ✅ Good — type extracted to separate file
+// types.ts
+export type ButtonVariantType = "primary" | "muted" | "danger";
+
+// Button.tsx
+import { ButtonVariantType } from "./types";
+export const Button = ({
+    variant,
+}: {
+    variant?: ButtonVariantType,
+}) => { ... };
+
+// ❌ Bad — complex inline union type
+export const Button = ({
+    variant,
+}: {
+    variant?: "primary" | "muted" | "danger",  // Extract to named type
+}) => { ... };
+```
+
+---
+
 ### `type-format`
 
 **What it does:** Enforces consistent formatting for TypeScript type aliases:

package/index.js

@@ -4030,10 +4030,31 @@ const ternaryConditionMultiline = {
             return false;
         };
 
+        // Check if ? or : is on its own line without its value
+        const isOperatorOnOwnLineHandler = (node) => {
+            const questionToken = sourceCode.getTokenAfter(node.test, (t) => t.value === "?");
+            const colonToken = sourceCode.getTokenAfter(node.consequent, (t) => t.value === ":");
+
+            // Check if ? is on different line than consequent start
+            if (questionToken && node.consequent.loc.start.line !== questionToken.loc.start.line) {
+                return true;
+            }
+
+            // Check if : is on different line than alternate start
+            if (colonToken && node.alternate.loc.start.line !== colonToken.loc.start.line) {
+                return true;
+            }
+
+            return false;
+        };
+
         // Handle simple ternaries - collapse to single line if they fit
         const handleSimpleTernaryHandler = (node) => {
-            // Skip if already on single line
-            if (node.loc.start.line === node.loc.end.line) return false;
+            const isOnSingleLine = node.loc.start.line === node.loc.end.line;
+            const hasOperatorOnOwnLine = isOperatorOnOwnLineHandler(node);
+
+            // Skip if already on single line and no formatting issues
+            if (isOnSingleLine && !hasOperatorOnOwnLine) return false;
 
             // Skip nested ternaries
             if (node.consequent.type === "ConditionalExpression" || node.alternate.type === "ConditionalExpression") {
@@ -4097,7 +4118,7 @@ const ternaryConditionMultiline = {
             const testEndLine = test.loc.end.line;
             const isMultiLine = testStartLine !== testEndLine;
 
-            // ≤maxOperands operands: keep condition on single line
+            // ≤maxOperands operands: keep condition on single line, and try to collapse whole ternary
             if (operands.length <= maxOperands) {
                 const firstOperandStartLine = operands[0].loc.start.line;
                 const allOperandsStartOnSameLine = operands.every(
@@ -4108,29 +4129,82 @@ const ternaryConditionMultiline = {
                     (op) => isBinaryExpressionSplitHandler(op),
                 );
 
-                if (!allOperandsStartOnSameLine || hasSplitBinaryExpression) {
-                    context.report({
-                        fix: (fixer) => {
-                            const buildSameLineHandler = (n) => {
-                                if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
-                                    const leftText = buildSameLineHandler(n.left);
-                                    const rightText = buildSameLineHandler(n.right);
+                // Check if ? or : is on its own line without its value
+                const hasOperatorOnOwnLine = isOperatorOnOwnLineHandler(node);
 
-                                    return `${leftText} ${n.operator} ${rightText}`;
-                                }
+                // Check if ternary is multiline (could be collapsed)
+                const isTernaryMultiline = node.loc.start.line !== node.loc.end.line;
 
-                                if (n.type === "BinaryExpression" && isBinaryExpressionSplitHandler(n)) {
-                                    return buildBinaryExpressionSingleLineHandler(n);
-                                }
+                // Helper to build single line condition
+                const buildSameLineHandler = (n) => {
+                    if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
+                        const leftText = buildSameLineHandler(n.left);
+                        const rightText = buildSameLineHandler(n.right);
 
-                                return getSourceTextWithGroupsHandler(n);
-                            };
+                        return `${leftText} ${n.operator} ${rightText}`;
+                    }
 
-                            return fixer.replaceText(test, buildSameLineHandler(test));
-                        },
-                        message: `Ternary conditions with ≤${maxOperands} operands should be single line`,
-                        node: test,
-                    });
+                    if (n.type === "BinaryExpression" && isBinaryExpressionSplitHandler(n)) {
+                        return buildBinaryExpressionSingleLineHandler(n);
+                    }
+
+                    return getSourceTextWithGroupsHandler(n);
+                };
+
+                // Check if whole ternary can fit on one line
+                const singleLineText = getTernarySingleLineHandler(node);
+                const indent = getLineIndentHandler(node);
+
+                // Calculate prefix length for context
+                let prefixLength = 0;
+                const parent = node.parent;
+
+                if (parent && parent.type === "VariableDeclarator" && parent.init === node) {
+                    const varDecl = parent.parent;
+                    const declKeyword = varDecl ? sourceCode.getFirstToken(varDecl).value : "const";
+                    const varName = parent.id.name || sourceCode.getText(parent.id);
+
+                    prefixLength = declKeyword.length + 1 + varName.length + 3;
+                } else if (parent && parent.type === "AssignmentExpression" && parent.right === node) {
+                    const leftText = sourceCode.getText(parent.left);
+
+                    prefixLength = leftText.length + 3;
+                } else if (parent && parent.type === "Property" && parent.value === node) {
+                    const keyText = sourceCode.getText(parent.key);
+
+                    prefixLength = keyText.length + 2;
+                }
+
+                const totalLength = indent + prefixLength + singleLineText.length + 1;
+                const canFitOnOneLine = totalLength <= maxLineLength;
+
+                // Skip if branches have complex objects
+                const hasComplexBranches = hasComplexObjectHandler(node.consequent) || hasComplexObjectHandler(node.alternate);
+
+                // Skip nested ternaries
+                const hasNestedTernary = node.consequent.type === "ConditionalExpression" || node.alternate.type === "ConditionalExpression";
+
+                // Determine if we need to fix anything
+                const needsConditionFix = !allOperandsStartOnSameLine || hasSplitBinaryExpression;
+                const needsTernaryCollapse = isTernaryMultiline && canFitOnOneLine && !hasComplexBranches && !hasNestedTernary;
+                const needsOperatorFix = hasOperatorOnOwnLine;
+
+                if (needsConditionFix || needsTernaryCollapse || needsOperatorFix) {
+                    // If whole ternary can fit on one line, collapse it
+                    if (canFitOnOneLine && !hasComplexBranches && !hasNestedTernary) {
+                        context.report({
+                            fix: (fixer) => fixer.replaceText(node, singleLineText),
+                            message: `Ternary with ≤${maxOperands} operands should be on single line when it fits`,
+                            node,
+                        });
+                    } else if (needsConditionFix) {
+                        // Otherwise just fix the condition to be on single line
+                        context.report({
+                            fix: (fixer) => fixer.replaceText(test, buildSameLineHandler(test)),
+                            message: `Ternary conditions with ≤${maxOperands} operands should be single line`,
+                            node: test,
+                        });
+                    }
                 }
 
                 return;
@@ -4178,6 +4252,11 @@ const ternaryConditionMultiline = {
                         isCorrectionNeeded = true;
                     }
                 }
+
+                // Check if ? or : is on its own line without its value
+                if (!isCorrectionNeeded && isOperatorOnOwnLineHandler(node)) {
+                    isCorrectionNeeded = true;
+                }
             }
 
             if (isCorrectionNeeded) {
@@ -4267,6 +4346,8 @@ const ternaryConditionMultiline = {
  *   statement (if, try, for, while, etc.) and the next statement,
  *   unless the next statement is part of the same construct (else, catch, finally).
  *
+ * Note: Consecutive if statements are handled by if-else-spacing rule.
+ *
  * ✓ Good:
  *   if (condition) {
  *       doSomething();
@@ -4347,6 +4428,11 @@ const emptyLineAfterBlock = {
                 // Get the next statement
                 const nextStmt = grandparent.body[stmtIndex + 1];
 
+                // Skip consecutive if statements - handled by if-else-spacing rule
+                if (parent.type === "IfStatement" && nextStmt.type === "IfStatement") {
+                    return;
+                }
+
                 // Get the actual end of the current statement
                 const currentEndLine = getStatementEndLineHandler(parent);
                 const nextStartLine = nextStmt.loc.start.line;
@@ -7512,12 +7598,16 @@ const classNameNoExtraSpaces = {
  *
  * Description:
  *   Enforce Tailwind CSS class ordering in class string variables,
- *   object properties, and return statements. Complements
- *   tailwindcss/classnames-order by handling cases it doesn't cover.
+ *   object properties, and return statements. This rule complements
+ *   tailwindcss/classnames-order by handling areas it doesn't cover.
  *   Uses smart detection: checks if values look like Tailwind classes.
  *
- * Note: This rule does NOT check JSX className attributes directly,
- *       as those should be handled by tailwindcss/classnames-order.
+ * Coverage Division:
+ *   - tailwindcss/classnames-order: Handles JSX className attributes
+ *   - classname-order (this rule): Handles variables, object properties,
+ *     and return statements containing Tailwind class strings
+ *
+ * Both rules should be enabled together for complete coverage.
  *
  * ✓ Good:
  *   const variants = { primary: "bg-blue-500 hover:bg-blue-600" };
@@ -7846,6 +7936,11 @@ const classNameMultiline = {
                     return getLineIndent(current);
                 }
 
+                // For return statements, use the return keyword's indentation
+                if (current.type === "ReturnStatement") {
+                    return getLineIndent(current);
+                }
+
                 current = current.parent;
             }
 
@@ -9534,6 +9629,8 @@ const noEmptyLinesInFunctionCalls = {
  * Description:
  *   Function parameter lists should not contain empty lines
  *   between parameters or after opening/before closing parens.
+ *   Also checks inside ObjectPattern (destructuring) params for
+ *   empty lines after {, before }, or between properties.
  *
  * ✓ Good:
  *   function test(
@@ -9541,12 +9638,23 @@ const noEmptyLinesInFunctionCalls = {
  *       param2,
  *   ) {}
  *
+ *   const Button = ({
+ *       children,
+ *       className,
+ *   }) => {};
+ *
  * ✗ Bad:
  *   function test(
  *       param1,
  *
  *       param2,
  *   ) {}
+ *
+ *   const Button = ({
+ *
+ *       children,
+ *       className,
+ *   }) => {};
  */
 const noEmptyLinesInFunctionParams = {
     create(context) {
@@ -9618,24 +9726,64 @@ const noEmptyLinesInFunctionParams = {
 
             // Check inside ObjectPattern params for empty lines between destructured props
             params.forEach((param) => {
-                if (param.type === "ObjectPattern" && param.properties.length > 1) {
-                    for (let i = 0; i < param.properties.length - 1; i += 1) {
-                        const current = param.properties[i];
-                        const next = param.properties[i + 1];
+                if (param.type === "ObjectPattern" && param.properties.length > 0) {
+                    const firstProp = param.properties[0];
+                    const lastProp = param.properties[param.properties.length - 1];
 
-                        if (next.loc.start.line - current.loc.end.line > 1) {
-                            const commaToken = sourceCode.getTokenAfter(current, (t) => t.value === ",");
+                    // Find the opening brace of ObjectPattern
+                    const openBrace = sourceCode.getFirstToken(param);
 
+                    if (openBrace && openBrace.value === "{") {
+                        // Check for empty line after opening brace
+                        if (firstProp.loc.start.line - openBrace.loc.end.line > 1) {
                             context.report({
                                 fix: (fixer) => fixer.replaceTextRange(
-                                    [commaToken.range[1], next.range[0]],
-                                    "\n" + " ".repeat(next.loc.start.column),
+                                    [openBrace.range[1], firstProp.range[0]],
+                                    "\n" + " ".repeat(firstProp.loc.start.column),
                                 ),
-                                message: "No empty lines between destructured properties",
-                                node: next,
+                                message: "No empty line after opening brace in destructuring",
+                                node: firstProp,
+                            });
+                        }
+                    }
+
+                    // Find the closing brace of ObjectPattern
+                    const closeBrace = sourceCode.getLastToken(param);
+
+                    if (closeBrace && closeBrace.value === "}") {
+                        // Check for empty line before closing brace
+                        if (closeBrace.loc.start.line - lastProp.loc.end.line > 1) {
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange(
+                                    [lastProp.range[1], closeBrace.range[0]],
+                                    "\n" + " ".repeat(closeBrace.loc.start.column),
+                                ),
+                                message: "No empty line before closing brace in destructuring",
+                                node: lastProp,
                             });
                         }
                     }
+
+                    // Check for empty lines between properties
+                    if (param.properties.length > 1) {
+                        for (let i = 0; i < param.properties.length - 1; i += 1) {
+                            const current = param.properties[i];
+                            const next = param.properties[i + 1];
+
+                            if (next.loc.start.line - current.loc.end.line > 1) {
+                                const commaToken = sourceCode.getTokenAfter(current, (t) => t.value === ",");
+
+                                context.report({
+                                    fix: (fixer) => fixer.replaceTextRange(
+                                        [commaToken.range[1], next.range[0]],
+                                        "\n" + " ".repeat(next.loc.start.column),
+                                    ),
+                                    message: "No empty lines between destructured properties",
+                                    node: next,
+                                });
+                            }
+                        }
+                    }
                 }
             });
         };

package/package.json

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