eslint-plugin-code-style 1.6.1 → 1.6.6

package/CHANGELOG.md

@@ -7,6 +7,47 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.6.6] - 2026-02-01
+
+### Fixed
+
+- **`component-props-destructure`** - Detect body destructuring patterns (e.g., `const { name } = data;`) even without type annotations
+- **`component-props-destructure`** - Add auto-fix for body destructuring: moves props to parameter and removes body declaration
+
+---
+
+## [1.6.5] - 2026-02-01
+
+### Added
+
+- **`function-object-destructure`** - Add auto-fix: replaces destructured usages with dot notation and removes declaration
+
+---
+
+## [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
@@ -987,6 +1028,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[1.6.5]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.4...v1.6.5
+[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

package/index.js

@@ -12414,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();
-
-        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);
+        // 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();
+
+        // 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) => {
@@ -12430,31 +12447,72 @@ 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);
                     }
                 });
             }
         };
 
-        // Check for destructuring of data imports (not allowed)
+        // Find all references to a variable name in a scope (with parent tracking)
+        const findAllReferencesHandler = (scope, varName, declNode) => {
+            const references = [];
+
+            const visitNode = (n, parent) => {
+                if (!n || typeof n !== "object") return;
+
+                // Skip the declaration itself
+                if (n === declNode) return;
+
+                // Found a reference
+                if (n.type === "Identifier" && n.name === varName) {
+                    // Make sure it's not a property key or part of a member expression property
+                    const isMemberProp = parent && parent.type === "MemberExpression" && parent.property === n && !parent.computed;
+                    const isObjectKey = parent && parent.type === "Property" && parent.key === n && !parent.computed;
+                    const isShorthandValue = parent && parent.type === "Property" && parent.shorthand && parent.value === n;
+
+                    // Include shorthand properties as references (they use the variable)
+                    if (!isMemberProp && !isObjectKey) {
+                        references.push(n);
+                    }
+                }
+
+                for (const key of Object.keys(n)) {
+                    if (key === "parent" || key === "range" || key === "loc") continue;
+
+                    const child = n[key];
+
+                    if (Array.isArray(child)) {
+                        child.forEach((c) => visitNode(c, n));
+                    } else if (child && typeof child === "object" && child.type) {
+                        visitNode(child, n);
+                    }
+                }
+            };
+
+            visitNode(scope, null);
+
+            return references;
+        };
+
+        // Check for destructuring of module imports (not allowed)
         const checkVariableDeclarationHandler = (node) => {
             for (const decl of node.declarations) {
                 // Check for ObjectPattern destructuring
                 if (decl.id.type === "ObjectPattern" && decl.init) {
                     let sourceVarName = null;
 
-                    // Direct destructuring: const { x } = dataImport
+                    // Direct destructuring: const { x } = moduleImport
                     if (decl.init.type === "Identifier") {
                         sourceVarName = decl.init.name;
                     }
 
-                    // Nested destructuring: const { x } = dataImport.nested
+                    // Nested destructuring: const { x } = moduleImport.nested
                     if (decl.init.type === "MemberExpression") {
                         let obj = decl.init;
 
@@ -12467,15 +12525,77 @@ const functionObjectDestructure = {
                         }
                     }
 
-                    if (sourceVarName && dataImports.has(sourceVarName)) {
+                    if (sourceVarName && moduleImports.has(sourceVarName)) {
+                        // Get destructured properties with their local names
                         const destructuredProps = decl.id.properties
                             .filter((p) => p.type === "Property" && p.key && p.key.name)
-                            .map((p) => p.key.name);
+                            .map((p) => ({
+                                key: p.key.name,
+                                local: p.value && p.value.type === "Identifier" ? p.value.name : p.key.name,
+                            }));
 
                         const sourceText = sourceCode.getText(decl.init);
 
+                        // Find the containing function/program to search for references
+                        let scope = node.parent;
+
+                        while (scope && scope.type !== "BlockStatement" && scope.type !== "Program") {
+                            scope = scope.parent;
+                        }
+
                         context.report({
-                            message: `Do not destructure data imports. Use dot notation for searchability: "${sourceText}.${destructuredProps[0]}" instead of destructuring`,
+                            fix: scope
+                                ? (fixer) => {
+                                    const fixes = [];
+
+                                    // Replace all references with dot notation
+                                    destructuredProps.forEach(({ key, local }) => {
+                                        const refs = findAllReferencesHandler(scope, local, decl);
+
+                                        refs.forEach((ref) => {
+                                            fixes.push(fixer.replaceText(ref, `${sourceText}.${key}`));
+                                        });
+                                    });
+
+                                    // Remove the entire declaration statement
+                                    // If it's the only declaration in the statement, remove the whole statement
+                                    if (node.declarations.length === 1) {
+                                        // Find the full statement including newline
+                                        const tokenBefore = sourceCode.getTokenBefore(node);
+                                        const tokenAfter = sourceCode.getTokenAfter(node);
+                                        let start = node.range[0];
+                                        let end = node.range[1];
+
+                                        // Include leading whitespace/newline
+                                        if (tokenBefore) {
+                                            const textBetween = sourceCode.text.slice(tokenBefore.range[1], node.range[0]);
+                                            const newlineIndex = textBetween.lastIndexOf("\n");
+
+                                            if (newlineIndex !== -1) {
+                                                start = tokenBefore.range[1] + newlineIndex;
+                                            }
+                                        }
+
+                                        // Include trailing newline
+                                        if (tokenAfter) {
+                                            const textBetween = sourceCode.text.slice(node.range[1], tokenAfter.range[0]);
+                                            const newlineIndex = textBetween.indexOf("\n");
+
+                                            if (newlineIndex !== -1) {
+                                                end = node.range[1] + newlineIndex + 1;
+                                            }
+                                        }
+
+                                        fixes.push(fixer.removeRange([start, end]));
+                                    } else {
+                                        // Remove just this declarator
+                                        fixes.push(fixer.remove(decl));
+                                    }
+
+                                    return fixes;
+                                }
+                                : undefined,
+                            message: `Do not destructure module imports. Use dot notation for searchability: "${sourceText}.${destructuredProps[0].key}" instead of destructuring`,
                             node: decl.id,
                         });
                     }
@@ -13258,6 +13378,66 @@ const componentPropsDestructure = {
             return accesses;
         };
 
+        // Find body destructuring like: const { name } = data; or const { name, age } = data;
+        const findBodyDestructuringHandler = (body, paramName) => {
+            const results = [];
+
+            if (body.type !== "BlockStatement") return results;
+
+            for (const statement of body.body) {
+                if (statement.type === "VariableDeclaration") {
+                    for (const declarator of statement.declarations) {
+                        // Check if it's destructuring from the param: const { x } = paramName
+                        if (
+                            declarator.id.type === "ObjectPattern" &&
+                            declarator.init &&
+                            declarator.init.type === "Identifier" &&
+                            declarator.init.name === paramName
+                        ) {
+                            const props = [];
+
+                            for (const prop of declarator.id.properties) {
+                                if (prop.type === "Property" && prop.key.type === "Identifier") {
+                                    // Handle both { name } and { name: alias }
+                                    const keyName = prop.key.name;
+                                    const valueName = prop.value.type === "Identifier" ? prop.value.name : null;
+                                    const hasDefault = prop.value.type === "AssignmentPattern";
+                                    let defaultValue = null;
+
+                                    if (hasDefault && prop.value.right) {
+                                        defaultValue = sourceCode.getText(prop.value.right);
+                                    }
+
+                                    props.push({
+                                        default: defaultValue,
+                                        hasAlias: keyName !== valueName && !hasDefault,
+                                        key: keyName,
+                                        value: hasDefault ? prop.value.left.name : valueName,
+                                    });
+                                } else if (prop.type === "RestElement" && prop.argument.type === "Identifier") {
+                                    props.push({
+                                        isRest: true,
+                                        key: prop.argument.name,
+                                        value: prop.argument.name,
+                                    });
+                                }
+                            }
+
+                            results.push({
+                                declarator,
+                                props,
+                                statement,
+                                // Track if this is the only declarator in the statement
+                                statementHasOnlyThisDeclarator: statement.declarations.length === 1,
+                            });
+                        }
+                    }
+                }
+            }
+
+            return results;
+        };
+
         const checkComponentPropsHandler = (node) => {
             if (!isReactComponentHandler(node)) return;
 
@@ -13271,14 +13451,33 @@ const componentPropsDestructure = {
 
             if (firstParam.type === "Identifier") {
                 const paramName = firstParam.name;
+
+                // Find dot notation accesses: props.name
                 const accesses = findPropAccessesHandler(node.body, paramName);
-                const accessedProps = [...new Set(accesses.map((a) => a.property))];
 
-                // Check if param is used directly (not just via dot notation)
+                // Find body destructuring: const { name } = props
+                const bodyDestructures = findBodyDestructuringHandler(node.body, paramName);
+
+                // Collect all accessed props from dot notation
+                const dotNotationProps = [...new Set(accesses.map((a) => a.property))];
+
+                // Collect all props from body destructuring
+                const bodyDestructuredProps = [];
+
+                bodyDestructures.forEach((bd) => {
+                    bd.props.forEach((p) => {
+                        bodyDestructuredProps.push(p);
+                    });
+                });
+
+                // Check if param is used anywhere that we can't handle
                 const allRefs = [];
-                const countRefs = (n) => {
+                const countRefs = (n, skipNodes = []) => {
                     if (!n || typeof n !== "object") return;
 
+                    // Skip nodes we're already accounting for
+                    if (skipNodes.includes(n)) return;
+
                     if (n.type === "Identifier" && n.name === paramName) allRefs.push(n);
 
                     for (const key of Object.keys(n)) {
@@ -13286,29 +13485,96 @@ const componentPropsDestructure = {
 
                         const child = n[key];
 
-                        if (Array.isArray(child)) child.forEach(countRefs);
-                        else if (child && typeof child === "object" && child.type) countRefs(child);
+                        if (Array.isArray(child)) child.forEach((c) => countRefs(c, skipNodes));
+                        else if (child && typeof child === "object" && child.type) countRefs(child, skipNodes);
                     }
                 };
 
                 countRefs(node.body);
 
-                // Can only auto-fix if all references are covered by dot notation accesses
-                const canAutoFix = accessedProps.length > 0 && allRefs.length === accesses.length;
+                // Count expected refs: dot notation accesses + body destructuring init nodes
+                const expectedRefCount = accesses.length + bodyDestructures.length;
+
+                // Can auto-fix if:
+                // 1. We have either dot notation props OR body destructured props
+                // 2. All references to the param are accounted for
+                const hasSomeProps = dotNotationProps.length > 0 || bodyDestructuredProps.length > 0;
+                const canAutoFix = hasSomeProps && allRefs.length === expectedRefCount;
 
                 context.report({
                     fix: canAutoFix
                         ? (fixer) => {
                             const fixes = [];
 
+                            // Build the destructured props list for the parameter
+                            const allProps = [];
+
+                            // Add dot notation props (simple names)
+                            dotNotationProps.forEach((p) => {
+                                if (!allProps.some((ap) => ap.key === p)) {
+                                    allProps.push({ key: p, simple: true });
+                                }
+                            });
+
+                            // Add body destructured props (may have aliases, defaults, rest)
+                            bodyDestructuredProps.forEach((p) => {
+                                // Don't duplicate if already in dot notation
+                                if (!allProps.some((ap) => ap.key === p.key)) {
+                                    allProps.push(p);
+                                }
+                            });
+
+                            // Build the destructured pattern string
+                            const propStrings = allProps.map((p) => {
+                                if (p.isRest) return `...${p.key}`;
+
+                                if (p.simple) return p.key;
+
+                                if (p.default) return `${p.key} = ${p.default}`;
+
+                                if (p.hasAlias) return `${p.key}: ${p.value}`;
+
+                                return p.key;
+                            });
+                            const destructuredPattern = `{ ${propStrings.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) => {
                                 fixes.push(fixer.replaceText(access.node, access.property));
                             });
 
+                            // Remove body destructuring statements
+                            bodyDestructures.forEach((bd) => {
+                                if (bd.statementHasOnlyThisDeclarator) {
+                                    // Remove the entire statement including newline
+                                    const statementStart = bd.statement.range[0];
+                                    let statementEnd = bd.statement.range[1];
+
+                                    // Try to also remove trailing newline/whitespace
+                                    const textAfter = sourceCode.getText().slice(statementEnd, statementEnd + 2);
+
+                                    if (textAfter.startsWith("\n")) statementEnd += 1;
+                                    else if (textAfter.startsWith("\r\n")) statementEnd += 2;
+
+                                    fixes.push(fixer.removeRange([statementStart, statementEnd]));
+                                } else {
+                                    // Only remove this declarator from a multi-declarator statement
+                                    // This is more complex - for now just remove the declarator text
+                                    fixes.push(fixer.remove(bd.declarator));
+                                }
+                            });
+
                             return fixes;
                         }
                         : undefined,

package/package.json

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