eslint-plugin-code-style 1.6.4 → 1.6.6

package/CHANGELOG.md

@@ -7,6 +7,23 @@ 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
@@ -1011,6 +1028,7 @@ 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

package/index.js

@@ -12459,19 +12459,60 @@ const functionObjectDestructure = {
             }
         };
 
-        // 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;
 
@@ -12485,14 +12526,76 @@ const functionObjectDestructure = {
                     }
 
                     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 module 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,
                         });
                     }
@@ -13275,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;
 
@@ -13288,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)) {
@@ -13303,23 +13485,58 @@ 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 destructured pattern, preserving type annotation if present
-                            const destructuredPattern = `{ ${accessedProps.join(", ")} }`;
+                            // 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
@@ -13337,6 +13554,27 @@ const componentPropsDestructure = {
                                 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.4",
+    "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",