@blumintinc/eslint-plugin-blumint 1.8.0 → 1.8.2

package/lib/rules/no-type-assertion-returns.js

@@ -22,6 +22,54 @@ function isAsConstAssertion(node) {
 function isTypePredicate(node) {
     return node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypePredicate;
 }
+/**
+ * Checks if a node is inside a return statement
+ */
+function isInsideReturnStatement(node) {
+    let current = node;
+    while (current?.parent) {
+        if (current.parent.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/**
+ * Checks if a node is inside a conditional statement
+ */
+function isInsideConditionalStatement(node) {
+    let current = node;
+    while (current?.parent) {
+        if (current.parent.type === utils_1.AST_NODE_TYPES.IfStatement ||
+            current.parent.type === utils_1.AST_NODE_TYPES.WhileStatement ||
+            current.parent.type === utils_1.AST_NODE_TYPES.DoWhileStatement ||
+            current.parent.type === utils_1.AST_NODE_TYPES.ForStatement ||
+            current.parent.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+            // If we're in a conditional statement but not in a return statement, it's valid
+            return !isInsideReturnStatement(current.parent);
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/**
+ * Checks if a type assertion is used to access a property
+ */
+function isPropertyAccess(node) {
+    return (node.parent?.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        node.parent.object === node);
+}
+/**
+ * Checks if a type assertion is used within an array includes check
+ */
+function isArrayIncludesCheck(node) {
+    return (node.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        node.parent.arguments.includes(node) &&
+        node.parent.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        node.parent.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.parent.callee.property.name === 'includes');
+}
 exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
     name: 'no-type-assertion-returns',
     meta: {
@@ -50,6 +98,94 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
     defaultOptions: [defaultOptions],
     create(context, [options]) {
         const mergedOptions = { ...defaultOptions, ...options };
+        /**
+         * Common function to check if a type assertion should be allowed
+         */
+        function shouldAllowTypeAssertion(node) {
+            // If the parent is a return statement, we already handle it in ReturnStatement
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+                return true;
+            }
+            // If the parent is an arrow function, we already handle it in ArrowFunctionExpression
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                return true;
+            }
+            // If the parent is a variable declarator, this is a variable declaration with type assertion
+            // which is a valid pattern and should not be flagged
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                return true;
+            }
+            // Allow type assertions within conditional statements (if, while, do-while, for)
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.IfStatement ||
+                node.parent?.type === utils_1.AST_NODE_TYPES.WhileStatement ||
+                node.parent?.type === utils_1.AST_NODE_TYPES.DoWhileStatement ||
+                node.parent?.type === utils_1.AST_NODE_TYPES.ForStatement) {
+                return true;
+            }
+            // Allow type assertions within logical expressions (which are often used in conditions)
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+                return true;
+            }
+            // Allow type assertions within method calls like array.includes()
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                node.parent.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                return true;
+            }
+            // Allow type assertions within array includes checks
+            if (isArrayIncludesCheck(node)) {
+                return true;
+            }
+            // Allow type assertions within conditional expressions, but only if they're not part of a return statement
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.ConditionalExpression && !isInsideReturnStatement(node)) {
+                return true;
+            }
+            // Allow type assertions used to access properties in conditional contexts
+            if (isPropertyAccess(node) && isInsideConditionalStatement(node)) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * Common function to check function return types
+         */
+        function checkFunctionReturnType(node) {
+            if (!node.returnType)
+                return;
+            // Allow type predicates if configured
+            if (mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+                return;
+            }
+            // If type predicates are not allowed, report them
+            if (!mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+                context.report({
+                    node: node.returnType,
+                    messageId: 'useExplicitVariable',
+                });
+                return;
+            }
+            // Check if the function has a return statement with a direct value (not a variable)
+            if (node.body && node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                for (const statement of node.body.body) {
+                    if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+                        // If returning a variable reference, that's fine
+                        if (statement.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            continue;
+                        }
+                        // If returning an object literal, array literal, or other complex expression
+                        // without first assigning it to a typed variable, that's a problem
+                        if (statement.argument.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+                            statement.argument.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                            statement.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                            context.report({
+                                node: node.returnType,
+                                messageId: 'useExplicitVariable',
+                            });
+                            break;
+                        }
+                    }
+                }
+            }
+        }
         return {
             // Check for return statements with type assertions
             ReturnStatement(node) {
@@ -84,81 +220,11 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
             },
             // Check functions with explicit return types
             FunctionDeclaration(node) {
-                if (!node.returnType)
-                    return;
-                // Allow type predicates if configured
-                if (mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
-                    return;
-                }
-                // If type predicates are not allowed, report them
-                if (!mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
-                    context.report({
-                        node: node.returnType,
-                        messageId: 'useExplicitVariable',
-                    });
-                    return;
-                }
-                // Check if the function has a return statement with a direct value (not a variable)
-                if (node.body && node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
-                    for (const statement of node.body.body) {
-                        if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
-                            // If returning a variable reference, that's fine
-                            if (statement.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                continue;
-                            }
-                            // If returning an object literal, array literal, or other complex expression
-                            // without first assigning it to a typed variable, that's a problem
-                            if (statement.argument.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
-                                statement.argument.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
-                                statement.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                                context.report({
-                                    node: node.returnType,
-                                    messageId: 'useExplicitVariable',
-                                });
-                                break;
-                            }
-                        }
-                    }
-                }
+                checkFunctionReturnType(node);
             },
             // Check function expressions with explicit return types
             FunctionExpression(node) {
-                if (!node.returnType)
-                    return;
-                // Allow type predicates if configured
-                if (mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
-                    return;
-                }
-                // If type predicates are not allowed, report them
-                if (!mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
-                    context.report({
-                        node: node.returnType,
-                        messageId: 'useExplicitVariable',
-                    });
-                    return;
-                }
-                // Check if the function has a return statement with a direct value (not a variable)
-                if (node.body && node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
-                    for (const statement of node.body.body) {
-                        if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
-                            // If returning a variable reference, that's fine
-                            if (statement.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                continue;
-                            }
-                            // If returning an object literal, array literal, or other complex expression
-                            // without first assigning it to a typed variable, that's a problem
-                            if (statement.argument.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
-                                statement.argument.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
-                                statement.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                                context.report({
-                                    node: node.returnType,
-                                    messageId: 'useExplicitVariable',
-                                });
-                                break;
-                            }
-                        }
-                    }
-                }
+                checkFunctionReturnType(node);
             },
             // Check arrow functions
             ArrowFunctionExpression(node) {
@@ -207,40 +273,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                 }
                 else if (node.returnType) {
                     // For arrow functions with block bodies
-                    // Allow type predicates if configured
-                    if (mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
-                        return;
-                    }
-                    // If type predicates are not allowed, report them
-                    if (!mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
-                        context.report({
-                            node: node.returnType,
-                            messageId: 'useExplicitVariable',
-                        });
-                        return;
-                    }
-                    // Check if the function has a return statement with a direct value (not a variable)
-                    if (node.body && node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
-                        for (const statement of node.body.body) {
-                            if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
-                                // If returning a variable reference, that's fine
-                                if (statement.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                    continue;
-                                }
-                                // If returning an object literal, array literal, or other complex expression
-                                // without first assigning it to a typed variable, that's a problem
-                                if (statement.argument.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
-                                    statement.argument.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
-                                    statement.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                                    context.report({
-                                        node: node.returnType,
-                                        messageId: 'useExplicitVariable',
-                                    });
-                                    break;
-                                }
-                            }
-                        }
-                    }
+                    checkFunctionReturnType(node);
                 }
             },
             // Check for array methods with type assertions
@@ -253,12 +286,8 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                 if (mergedOptions.allowAsConst && isAsConstAssertion(node)) {
                     return;
                 }
-                // If the parent is a return statement, we already handle it in ReturnStatement
-                if (node.parent?.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
-                    return;
-                }
-                // If the parent is an arrow function, we already handle it in ArrowFunctionExpression
-                if (node.parent?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                // Use the common function to check if the type assertion should be allowed
+                if (shouldAllowTypeAssertion(node)) {
                     return;
                 }
                 // For standalone type assertions in expressions
@@ -269,12 +298,8 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
             },
             // Check for type assertions using angle bracket syntax
             TSTypeAssertion(node) {
-                // If the parent is a return statement, we already handle it in ReturnStatement
-                if (node.parent?.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
-                    return;
-                }
-                // If the parent is an arrow function, we already handle it in ArrowFunctionExpression
-                if (node.parent?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                // Use the common function to check if the type assertion should be allowed
+                if (shouldAllowTypeAssertion(node)) {
                     return;
                 }
                 // For standalone type assertions in expressions

package/lib/rules/no-unnecessary-destructuring.d.ts

@@ -0,0 +1,5 @@
+import { TSESTree } from '@typescript-eslint/utils';
+export declare const noUnnecessaryDestructuring: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noUnnecessaryDestructuring", never[], {
+    VariableDeclarator(node: TSESTree.VariableDeclarator): void;
+    AssignmentExpression(node: TSESTree.AssignmentExpression): void;
+}>;

package/lib/rules/no-unnecessary-destructuring.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnnecessaryDestructuring = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.noUnnecessaryDestructuring = (0, createRule_1.createRule)({
+    name: 'no-unnecessary-destructuring',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Avoid unnecessary object destructuring when there is only one property inside the destructured object',
+            recommended: 'error',
+        },
+        messages: {
+            noUnnecessaryDestructuring: 'Avoid unnecessary object destructuring with a single rest property. Use the object directly instead of `{ ...obj }`.',
+        },
+        schema: [],
+        fixable: 'code',
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            // Handle variable declarations
+            VariableDeclarator(node) {
+                if (node.id.type === 'ObjectPattern' &&
+                    node.id.properties.length === 1 &&
+                    node.id.properties[0].type === 'RestElement') {
+                    const restElement = node.id.properties[0];
+                    // Report the issue
+                    context.report({
+                        node,
+                        messageId: 'noUnnecessaryDestructuring',
+                        fix(fixer) {
+                            const sourceCode = context.getSourceCode();
+                            const restName = sourceCode.getText(restElement.argument);
+                            // Handle the case where init might be null
+                            if (!node.init) {
+                                return null;
+                            }
+                            const initText = sourceCode.getText(node.init);
+                            // Replace the destructuring with direct assignment
+                            return fixer.replaceText(node, `${restName} = ${initText}`);
+                        },
+                    });
+                }
+            },
+            // Handle assignments like { ...obj } = value
+            AssignmentExpression(node) {
+                if (node.operator === '=' &&
+                    node.left.type === 'ObjectPattern' &&
+                    node.left.properties.length === 1 &&
+                    node.left.properties[0].type === 'RestElement') {
+                    const restElement = node.left.properties[0];
+                    context.report({
+                        node,
+                        messageId: 'noUnnecessaryDestructuring',
+                        fix(fixer) {
+                            const sourceCode = context.getSourceCode();
+                            const restName = sourceCode.getText(restElement.argument);
+                            const rightText = sourceCode.getText(node.right);
+                            // Replace the destructuring with direct assignment
+                            return fixer.replaceText(node, `${restName} = ${rightText}`);
+                        },
+                    });
+                }
+            }
+        };
+    },
+});
+//# sourceMappingURL=no-unnecessary-destructuring.js.map

package/lib/rules/no-unused-props.js

@@ -21,11 +21,15 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
     create(context) {
         const propsTypes = new Map();
         const usedProps = new Map();
+        // Track which spread types have been used in a component
+        const usedSpreadTypes = new Map();
         let currentComponent = null;
         return {
             TSTypeAliasDeclaration(node) {
                 if (node.id.name.endsWith('Props')) {
                     const props = {};
+                    // Track which properties come from which spread type
+                    const spreadTypeProps = {};
                     function extractProps(typeNode) {
                         if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
                             typeNode.members.forEach((member) => {
@@ -45,6 +49,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                             const [baseType, pickedProps] = type.typeParameters.params;
                                             if (baseType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
                                                 baseType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                                const baseTypeName = baseType.typeName.name;
                                                 // Extract the picked properties from the union type
                                                 if (pickedProps.type === utils_1.AST_NODE_TYPES.TSUnionType) {
                                                     pickedProps.types.forEach((t) => {
@@ -52,7 +57,13 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                                             t.literal.type === utils_1.AST_NODE_TYPES.Literal &&
                                                             typeof t.literal.value === 'string') {
                                                             // Add each picked property as a regular prop
-                                                            props[t.literal.value] = t.literal;
+                                                            const propName = t.literal.value;
+                                                            props[propName] = t.literal;
+                                                            // Track that this prop comes from the base type
+                                                            if (!spreadTypeProps[baseTypeName]) {
+                                                                spreadTypeProps[baseTypeName] = [];
+                                                            }
+                                                            spreadTypeProps[baseTypeName].push(propName);
                                                         }
                                                     });
                                                 }
@@ -60,7 +71,13 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                                     pickedProps.literal.type === utils_1.AST_NODE_TYPES.Literal &&
                                                     typeof pickedProps.literal.value === 'string') {
                                                     // Single property pick
-                                                    props[pickedProps.literal.value] = pickedProps.literal;
+                                                    const propName = pickedProps.literal.value;
+                                                    props[propName] = pickedProps.literal;
+                                                    // Track that this prop comes from the base type
+                                                    if (!spreadTypeProps[baseTypeName]) {
+                                                        spreadTypeProps[baseTypeName] = [];
+                                                    }
+                                                    spreadTypeProps[baseTypeName].push(propName);
                                                 }
                                             }
                                         }
@@ -74,7 +91,13 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                             else {
                                                 // If we can't find the type declaration, it's likely an imported type
                                                 // Mark it as a forwarded prop
-                                                props[`...${typeName.name}`] = typeName;
+                                                const spreadTypeName = typeName.name;
+                                                props[`...${spreadTypeName}`] = typeName;
+                                                // For imported types, we need to track individual properties that might be used
+                                                // from this spread type, even if we don't know what they are yet
+                                                if (!spreadTypeProps[spreadTypeName]) {
+                                                    spreadTypeProps[spreadTypeName] = [];
+                                                }
                                             }
                                         }
                                     }
@@ -91,6 +114,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                     const [baseType, pickedProps] = typeNode.typeParameters.params;
                                     if (baseType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
                                         baseType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                        const baseTypeName = baseType.typeName.name;
                                         // Extract the picked properties from the union type
                                         if (pickedProps.type === utils_1.AST_NODE_TYPES.TSUnionType) {
                                             pickedProps.types.forEach((type) => {
@@ -98,7 +122,13 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                                     type.literal.type === utils_1.AST_NODE_TYPES.Literal &&
                                                     typeof type.literal.value === 'string') {
                                                     // Add each picked property as a regular prop
-                                                    props[type.literal.value] = type.literal;
+                                                    const propName = type.literal.value;
+                                                    props[propName] = type.literal;
+                                                    // Track that this prop comes from the base type
+                                                    if (!spreadTypeProps[baseTypeName]) {
+                                                        spreadTypeProps[baseTypeName] = [];
+                                                    }
+                                                    spreadTypeProps[baseTypeName].push(propName);
                                                 }
                                             });
                                         }
@@ -106,19 +136,44 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                             pickedProps.literal.type === utils_1.AST_NODE_TYPES.Literal &&
                                             typeof pickedProps.literal.value === 'string') {
                                             // Single property pick
-                                            props[pickedProps.literal.value] = pickedProps.literal;
+                                            const propName = pickedProps.literal.value;
+                                            props[propName] = pickedProps.literal;
+                                            // Track that this prop comes from the base type
+                                            if (!spreadTypeProps[baseTypeName]) {
+                                                spreadTypeProps[baseTypeName] = [];
+                                            }
+                                            spreadTypeProps[baseTypeName].push(propName);
                                         }
                                     }
                                 }
                                 else {
                                     // For referenced types like FormControlLabelProps, we need to track that these props should be forwarded
-                                    props[`...${typeNode.typeName.name}`] = typeNode.typeName;
+                                    const spreadTypeName = typeNode.typeName.name;
+                                    props[`...${spreadTypeName}`] = typeNode.typeName;
+                                    // For imported types, we need to track individual properties that might be used
+                                    // from this spread type, even if we don't know what they are yet
+                                    if (!spreadTypeProps[spreadTypeName]) {
+                                        spreadTypeProps[spreadTypeName] = [];
+                                    }
                                 }
                             }
                         }
                     }
                     extractProps(node.typeAnnotation);
                     propsTypes.set(node.id.name, props);
+                    // Store the mapping of spread types to their properties
+                    const typeName = node.id.name;
+                    usedSpreadTypes.set(typeName, new Set(Object.keys(spreadTypeProps)));
+                    // Store the spread type properties for later reference
+                    for (const [spreadType, propNames] of Object.entries(spreadTypeProps)) {
+                        // Create a map entry for this spread type if it doesn't exist
+                        if (!usedSpreadTypes.has(spreadType)) {
+                            usedSpreadTypes.set(spreadType, new Set());
+                        }
+                        // Add the property names to the spread type's set
+                        const spreadTypeSet = usedSpreadTypes.get(spreadType);
+                        propNames.forEach(prop => spreadTypeSet.add(prop));
+                    }
                 }
             },
             VariableDeclaration(node) {
@@ -168,11 +223,54 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                     if (propsType && used) {
                         Object.keys(propsType).forEach((prop) => {
                             if (!used.has(prop)) {
-                                context.report({
-                                    node: propsType[prop],
-                                    messageId: 'unusedProp',
-                                    data: { propName: prop },
-                                });
+                                // For imported types (props that start with '...'), only report if there's no rest spread operator
+                                // This allows imported types to be used without being flagged when properly forwarded
+                                const hasRestSpread = Array.from(used.values()).some(usedProp => usedProp.startsWith('...'));
+                                // Don't report unused props if:
+                                // 1. It's a spread type and there's a rest spread operator, OR
+                                // 2. It's a property from a spread type and any property from that spread type is used, OR
+                                // 3. It's a spread type and any of its properties are used in the component
+                                let shouldReport = true;
+                                if (prop.startsWith('...') && hasRestSpread) {
+                                    shouldReport = false;
+                                }
+                                else if (prop.startsWith('...')) {
+                                    // For spread types like "...GroupInfoBasic", check if any properties from this type are used
+                                    const spreadTypeName = prop.substring(3); // Remove the "..." prefix
+                                    // Get the properties that belong to this spread type
+                                    const spreadTypeProps = usedSpreadTypes.get(spreadTypeName);
+                                    if (spreadTypeProps) {
+                                        // Check if any property from this spread type is being used in the component
+                                        const anyPropFromSpreadTypeUsed = Array.from(spreadTypeProps).some(spreadProp => used.has(spreadProp));
+                                        if (anyPropFromSpreadTypeUsed) {
+                                            shouldReport = false;
+                                        }
+                                    }
+                                }
+                                else {
+                                    // Check if this prop might be from a spread type that has other properties being used
+                                    for (const [spreadType, props] of usedSpreadTypes.entries()) {
+                                        // Skip the current props type
+                                        if (spreadType === typeName)
+                                            continue;
+                                        // If this prop is from a spread type
+                                        if (props.has(prop)) {
+                                            // Check if any other prop from this spread type is being used
+                                            const anyPropFromSpreadTypeUsed = Array.from(props).some(spreadProp => used.has(spreadProp));
+                                            if (anyPropFromSpreadTypeUsed) {
+                                                shouldReport = false;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                                if (shouldReport) {
+                                    context.report({
+                                        node: propsType[prop],
+                                        messageId: 'unusedProp',
+                                        data: { propName: prop },
+                                    });
+                                }
                             }
                         });
                     }

package/lib/rules/no-unused-usestate.d.ts

@@ -0,0 +1,8 @@
+import { TSESTree } from '@typescript-eslint/utils';
+/**
+ * Rule to detect and remove unused useState hooks in React components
+ * This rule identifies cases where the state variable from useState is ignored (e.g., replaced with _)
+ */
+export declare const noUnusedUseState: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unusedUseState", never[], {
+    VariableDeclarator(node: TSESTree.VariableDeclarator): void;
+}>;