eslint-plugin-code-style 1.6.0 → 1.6.4

package/CHANGELOG.md

@@ -7,11 +7,52 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.6.4] - 2026-02-01
+
+### Enhanced
+
+- **`function-object-destructure`** - Add more module paths: apis, configs, utilities, routes
+
+---
+
+## [1.6.3] - 2026-02-01
+
+### Fixed
+
+- **`component-props-destructure`** - Preserve TypeScript type annotation when auto-fixing
+
+---
+
+## [1.6.2] - 2026-02-01
+
+### Enhanced
+
+- **`function-object-destructure`** - Expand to check more module paths (services, constants, config, api, utils, helpers, lib) for dot notation enforcement
+
+---
+
+## [1.6.1] - 2026-02-01
+
+### Enhanced
+
+- **`function-params-per-line`** - Handle callbacks with mixed params (destructured + simple like `({ item }, index)`)
+- **`array-callback-destructure`** - Fix closing brace on same line as last property
+- **`simple-call-single-line`** - Skip callbacks with 2+ params to avoid conflicts
+- **`jsx-simple-element-one-line`** - Treat simple function calls (0-1 args) as simple expressions
+- **`jsx-children-on-new-line`** - Treat simple function calls (0-1 args) as simple expressions
+- **`jsx-element-child-new-line`** - Treat simple function calls (0-1 args) as simple expressions
+
+### Docs
+
+- Clarify version bump and tag workflow in AGENTS.md
+
+---
+
 ## [1.6.0] - 2026-02-01
 
 **New array-callback-destructure Rule & Multiple Enhancements**
 
-**Version Range:** v1.5.2 → v1.6.0
+**Version Range:** v1.5.1 → v1.6.0
 
 ### Added
 
@@ -33,7 +74,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Auto-fixable: 60 rules 🔧
 - Report-only: 6 rules
 
-**Full Changelog:** [v1.5.2...v1.6.0](https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.5.2...v1.6.0)
+**Full Changelog:** [v1.5.1...v1.6.0](https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.5.1...v1.6.0)
 
 ---
 
@@ -970,6 +1011,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[1.6.4]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.3...v1.6.4
+[1.6.3]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.2...v1.6.3
+[1.6.2]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.1...v1.6.2
+[1.6.1]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.0...v1.6.1
 [1.6.0]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.5.2...v1.6.0
 [1.5.2]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.5.1...v1.5.2
 [1.5.1]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.5.0...v1.5.1

package/index.js

@@ -585,20 +585,20 @@ const arrayCallbackDestructure = {
             // Only enforce multiline when 2+ properties
             if (properties.length < 2) return;
 
-            // Check if all properties are on the same line
             const firstProp = properties[0];
             const lastProp = properties[properties.length - 1];
+            const closeBrace = sourceCode.getLastToken(pattern);
 
-            if (firstProp.loc.start.line === lastProp.loc.end.line) {
-                // Calculate indent based on the call expression
-                const callLine = sourceCode.lines[callNode.loc.start.line - 1];
-                const baseIndent = callLine.match(/^\s*/)[0];
-                const propIndent = baseIndent + "    ";
+            // Calculate indent based on the call expression
+            const callLine = sourceCode.lines[callNode.loc.start.line - 1];
+            const baseIndent = callLine.match(/^\s*/)[0];
+            const propIndent = baseIndent + "        ";
 
+            // Check if all properties are on the same line (need full reformat)
+            if (firstProp.loc.start.line === lastProp.loc.end.line) {
                 context.report({
                     fix(fixer) {
                         const openBrace = sourceCode.getFirstToken(pattern);
-                        const closeBrace = sourceCode.getLastToken(pattern);
 
                         const propsText = properties
                             .map((prop) => propIndent + sourceCode.getText(prop))
@@ -606,12 +606,39 @@ const arrayCallbackDestructure = {
 
                         return fixer.replaceTextRange(
                             [openBrace.range[0], closeBrace.range[1]],
-                            `{\n${propsText},\n${baseIndent}}`,
+                            `{\n${propsText},\n${baseIndent}    }`,
                         );
                     },
                     message: "Destructured properties in array callback should each be on their own line when there are 2 or more properties",
                     node: pattern,
                 });
+
+                return;
+            }
+
+            // Check if closing brace is on the same line as last property (needs fixing)
+            if (closeBrace.loc.start.line === lastProp.loc.end.line) {
+                context.report({
+                    fix(fixer) {
+                        // Add trailing comma if missing and move closing brace to new line
+                        const tokenBeforeClose = sourceCode.getTokenBefore(closeBrace);
+                        const hasTrailingComma = tokenBeforeClose.value === ",";
+
+                        if (hasTrailingComma) {
+                            return fixer.replaceTextRange(
+                                [tokenBeforeClose.range[1], closeBrace.range[0]],
+                                "\n" + baseIndent + "    ",
+                            );
+                        }
+
+                        return fixer.replaceTextRange(
+                            [lastProp.range[1], closeBrace.range[0]],
+                            ",\n" + baseIndent + "    ",
+                        );
+                    },
+                    message: "Closing brace should be on its own line in multiline destructuring",
+                    node: closeBrace,
+                });
             }
         };
 
@@ -2694,67 +2721,66 @@ const functionParamsPerLine = {
                 closeParen.range[0],
             );
 
-            // Callback arrow functions with 2+ simple params: each param on its own line
-            if (isCallback && params.length >= 2 && !hasComplexDestructuredParamHandler(params)) {
-                // Check if all params are simple identifiers (not destructuring)
-                const allSimpleParams = params.every((p) => p.type === "Identifier");
+            // Callback arrow functions with 2+ params: each param on its own line
+            // This handles both simple params (item, index) and mixed params ({ item }, index)
+            if (isCallback && params.length >= 2) {
+                // Calculate proper indent based on line's base indentation, not the paren column
+                // This ensures consistent indentation for callbacks in method chains
+                const lineText = sourceCode.lines[openParen.loc.start.line - 1];
+                const lineIndent = lineText.match(/^(\s*)/)[1].length;
+                const paramIndent = " ".repeat(lineIndent + 4);
+                const parenIndent = " ".repeat(lineIndent);
+
+                // Check if first param is on same line as opening paren
+                if (openParen.loc.end.line === firstParam.loc.start.line) {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange(
+                            [openParen.range[1], firstParam.range[0]],
+                            "\n" + paramIndent,
+                        ),
+                        message: "Callback arrow with 2+ params: first param should be on its own line",
+                        node: firstParam,
+                    });
+                }
+
+                // Check if closing paren is on same line as last param
+                if (closeParen.loc.start.line === lastParam.loc.end.line) {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange(
+                            [lastParam.range[1], closeParen.range[0]],
+                            ",\n" + parenIndent,
+                        ),
+                        message: "Callback arrow with 2+ params: closing paren should be on its own line",
+                        node: closeParen,
+                    });
+                }
+
+                // Check each param is on its own line
+                for (let i = 0; i < params.length - 1; i += 1) {
+                    const current = params[i];
+                    const next = params[i + 1];
 
-                if (allSimpleParams) {
-                    // Calculate proper indent based on opening paren position
-                    const paramIndent = " ".repeat(openParen.loc.start.column + 4);
-                    const parenIndent = " ".repeat(openParen.loc.start.column);
+                    if (current.loc.end.line === next.loc.start.line) {
+                        const commaToken = sourceCode.getTokenAfter(
+                            current,
+                            (token) => token.value === ",",
+                        );
 
-                    // Check if first param is on same line as opening paren
-                    if (openParen.loc.end.line === firstParam.loc.start.line) {
                         context.report({
                             fix: (fixer) => fixer.replaceTextRange(
-                                [openParen.range[1], firstParam.range[0]],
+                                [commaToken.range[1], next.range[0]],
                                 "\n" + paramIndent,
                             ),
-                            message: "Callback arrow with 2+ params: first param should be on its own line",
-                            node: firstParam,
-                        });
-                    }
-
-                    // Check if closing paren is on same line as last param
-                    if (closeParen.loc.start.line === lastParam.loc.end.line) {
-                        context.report({
-                            fix: (fixer) => fixer.replaceTextRange(
-                                [lastParam.range[1], closeParen.range[0]],
-                                ",\n" + parenIndent,
-                            ),
-                            message: "Callback arrow with 2+ params: closing paren should be on its own line",
-                            node: closeParen,
+                            message: "Callback arrow with 2+ params: each param should be on its own line",
+                            node: next,
                         });
                     }
-
-                    // Check each param is on its own line
-                    for (let i = 0; i < params.length - 1; i += 1) {
-                        const current = params[i];
-                        const next = params[i + 1];
-
-                        if (current.loc.end.line === next.loc.start.line) {
-                            const commaToken = sourceCode.getTokenAfter(
-                                current,
-                                (token) => token.value === ",",
-                            );
-
-                            context.report({
-                                fix: (fixer) => fixer.replaceTextRange(
-                                    [commaToken.range[1], next.range[0]],
-                                    "\n" + paramIndent,
-                                ),
-                                message: "Callback arrow with 2+ params: each param should be on its own line",
-                                node: next,
-                            });
-                        }
-                    }
-
-                    return;
                 }
+
+                return;
             }
 
-            // Skip other callback arrow functions (single param handled by opening-brackets-same-line)
+            // Skip single-param callback arrow functions (handled by opening-brackets-same-line)
             if (isCallback) return;
 
             // 1-2 simple params without complex destructuring: keep on same line
@@ -5651,7 +5677,19 @@ const jsxChildrenOnNewLine = {
     create(context) {
         const sourceCode = context.sourceCode || context.getSourceCode();
 
-        // Check if expression is simple (identifier, literal, or member expression chain)
+        // Check if an argument is simple
+        const isSimpleArgHandler = (node) => {
+            if (!node) return false;
+            if (node.type === "Identifier") return true;
+            if (node.type === "Literal") return true;
+            if (node.type === "MemberExpression") {
+                return node.object.type === "Identifier" && node.property.type === "Identifier";
+            }
+
+            return false;
+        };
+
+        // Check if expression is simple (identifier, literal, member expression chain, or simple function call)
         const isSimpleExpressionHandler = (expr) => {
             if (!expr) return true;
 
@@ -5677,6 +5715,22 @@ const jsxChildrenOnNewLine = {
                 return current.type === "Identifier";
             }
 
+            // Allow simple function calls with 0-1 simple arguments
+            if (expr.type === "CallExpression") {
+                const { callee } = expr;
+                const isSimpleCallee = callee.type === "Identifier" ||
+                    (callee.type === "MemberExpression" &&
+                     callee.object.type === "Identifier" &&
+                     callee.property.type === "Identifier");
+
+                if (!isSimpleCallee) return false;
+
+                if (expr.arguments.length === 0) return true;
+                if (expr.arguments.length === 1 && isSimpleArgHandler(expr.arguments[0])) return true;
+
+                return false;
+            }
+
             return false;
         };
 
@@ -5884,7 +5938,19 @@ const jsxElementChildNewLine = {
     create(context) {
         const sourceCode = context.sourceCode || context.getSourceCode();
 
-        // Check if expression is simple (identifier, literal, or member expression chain)
+        // Check if an argument is simple
+        const isSimpleArgHandler = (node) => {
+            if (!node) return false;
+            if (node.type === "Identifier") return true;
+            if (node.type === "Literal") return true;
+            if (node.type === "MemberExpression") {
+                return node.object.type === "Identifier" && node.property.type === "Identifier";
+            }
+
+            return false;
+        };
+
+        // Check if expression is simple (identifier, literal, member expression chain, or simple function call)
         const isSimpleExpressionHandler = (expr) => {
             if (!expr) return true;
 
@@ -5910,6 +5976,22 @@ const jsxElementChildNewLine = {
                 return current.type === "Identifier";
             }
 
+            // Allow simple function calls with 0-1 simple arguments
+            if (expr.type === "CallExpression") {
+                const { callee } = expr;
+                const isSimpleCallee = callee.type === "Identifier" ||
+                    (callee.type === "MemberExpression" &&
+                     callee.object.type === "Identifier" &&
+                     callee.property.type === "Identifier");
+
+                if (!isSimpleCallee) return false;
+
+                if (expr.arguments.length === 0) return true;
+                if (expr.arguments.length === 1 && isSimpleArgHandler(expr.arguments[0])) return true;
+
+                return false;
+            }
+
             return false;
         };
 
@@ -6436,7 +6518,19 @@ const jsxSimpleElementOneLine = {
     create(context) {
         const sourceCode = context.sourceCode || context.getSourceCode();
 
-        // Check if an expression is simple (just an identifier or literal)
+        // Check if an argument is simple (identifier, literal, or simple member expression)
+        const isSimpleArgHandler = (node) => {
+            if (!node) return false;
+            if (node.type === "Identifier") return true;
+            if (node.type === "Literal") return true;
+            if (node.type === "MemberExpression") {
+                return node.object.type === "Identifier" && node.property.type === "Identifier";
+            }
+
+            return false;
+        };
+
+        // Check if an expression is simple (identifier, literal, member expression, or simple function call)
         const isSimpleExpressionHandler = (node) => {
             if (!node) return false;
 
@@ -6447,6 +6541,24 @@ const jsxSimpleElementOneLine = {
                 return node.object.type === "Identifier" && node.property.type === "Identifier";
             }
 
+            // Allow simple function calls with 0-1 simple arguments
+            if (node.type === "CallExpression") {
+                // Check callee is simple (identifier or member expression)
+                const { callee } = node;
+                const isSimpleCallee = callee.type === "Identifier" ||
+                    (callee.type === "MemberExpression" &&
+                     callee.object.type === "Identifier" &&
+                     callee.property.type === "Identifier");
+
+                if (!isSimpleCallee) return false;
+
+                // Allow 0-1 arguments, and the argument must be simple
+                if (node.arguments.length === 0) return true;
+                if (node.arguments.length === 1 && isSimpleArgHandler(node.arguments[0])) return true;
+
+                return false;
+            }
+
             return false;
         };
 
@@ -11565,13 +11677,16 @@ const simpleCallSingleLine = {
                 // Argument must be arrow function
                 if (arg.type !== "ArrowFunctionExpression") return;
 
+                // Callbacks with 2+ params should be multiline (handled by function-params-per-line)
+                if (arg.params.length >= 2) return;
+
                 const { body } = arg;
 
                 // Zero params: body must be a simple call/import
                 if (arg.params.length === 0 && !isSimpleBodyHandler(body)) return;
 
-                // With params: body must be expression (not block) and simple
-                if (arg.params.length > 0) {
+                // With single param: body must be expression (not block) and simple
+                if (arg.params.length === 1) {
                     if (body.type === "BlockStatement") return;
                     if (!isSimpleExpressionHandler(body)) return;
                 }
@@ -12299,15 +12414,32 @@ const functionObjectDestructure = {
     create(context) {
         const sourceCode = context.sourceCode || context.getSourceCode();
 
-        // Track imports from data-related paths (should use dot notation, not destructure)
-        const dataImports = new Set();
+        // Track imports from module paths that should use dot notation, not destructure
+        // This improves searchability: api.loginHandler is easier to find than loginHandler
+        const moduleImports = new Set();
 
-        const isDataImportPath = (importPath) => {
-            // Match paths like @/data, ./data, ../data, or any path containing /data/
-            return importPath === "@/data"
-                || importPath.endsWith("/data")
-                || importPath.includes("/data/")
-                || /^\.\.?\/data$/.test(importPath);
+        // Folders that contain modules which should be accessed via dot notation
+        const modulePathPatterns = [
+            "api",
+            "apis",
+            "config",
+            "configs",
+            "constants",
+            "data",
+            "helpers",
+            "lib",
+            "routes",
+            "services",
+            "utils",
+            "utilities",
+        ];
+
+        const isModuleImportPath = (importPath) => {
+            // Match paths like @/services, @/constants, ./data, ../config, etc.
+            return modulePathPatterns.some((pattern) => importPath === `@/${pattern}`
+                    || importPath.endsWith(`/${pattern}`)
+                    || importPath.includes(`/${pattern}/`)
+                    || new RegExp(`^\\.?\\.?/${pattern}$`).test(importPath));
         };
 
         const checkImportHandler = (node) => {
@@ -12315,13 +12447,13 @@ const functionObjectDestructure = {
 
             const importPath = node.source.value;
 
-            if (isDataImportPath(importPath)) {
-                // Track all imported specifiers from data paths
+            if (isModuleImportPath(importPath)) {
+                // Track all imported specifiers from module paths
                 node.specifiers.forEach((spec) => {
                     if (spec.type === "ImportSpecifier" && spec.local && spec.local.name) {
-                        dataImports.add(spec.local.name);
+                        moduleImports.add(spec.local.name);
                     } else if (spec.type === "ImportDefaultSpecifier" && spec.local && spec.local.name) {
-                        dataImports.add(spec.local.name);
+                        moduleImports.add(spec.local.name);
                     }
                 });
             }
@@ -12352,7 +12484,7 @@ const functionObjectDestructure = {
                         }
                     }
 
-                    if (sourceVarName && dataImports.has(sourceVarName)) {
+                    if (sourceVarName && moduleImports.has(sourceVarName)) {
                         const destructuredProps = decl.id.properties
                             .filter((p) => p.type === "Property" && p.key && p.key.name)
                             .map((p) => p.key.name);
@@ -12360,7 +12492,7 @@ const functionObjectDestructure = {
                         const sourceText = sourceCode.getText(decl.init);
 
                         context.report({
-                            message: `Do not destructure data imports. Use dot notation for searchability: "${sourceText}.${destructuredProps[0]}" instead of destructuring`,
+                            message: `Do not destructure module imports. Use dot notation for searchability: "${sourceText}.${destructuredProps[0]}" instead of destructuring`,
                             node: decl.id,
                         });
                     }
@@ -13186,8 +13318,19 @@ const componentPropsDestructure = {
                         ? (fixer) => {
                             const fixes = [];
 
+                            // Build destructured pattern, preserving type annotation if present
+                            const destructuredPattern = `{ ${accessedProps.join(", ")} }`;
+                            let replacement = destructuredPattern;
+
+                            // Preserve TypeScript type annotation if present
+                            if (firstParam.typeAnnotation) {
+                                const typeText = sourceCode.getText(firstParam.typeAnnotation);
+
+                                replacement = `${destructuredPattern}${typeText}`;
+                            }
+
                             // Replace param with destructured pattern
-                            fixes.push(fixer.replaceText(firstParam, `{ ${accessedProps.join(", ")} }`));
+                            fixes.push(fixer.replaceText(firstParam, replacement));
 
                             // Replace all props.x with just x
                             accesses.forEach((access) => {

package/package.json

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