@blumintinc/eslint-plugin-blumint 1.13.0 → 1.14.0

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

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUnusedProps = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const PAREN_TYPE = utils_1.AST_NODE_TYPES.TSParenthesizedType ??
+    'TSParenthesizedType';
 exports.noUnusedProps = (0, createRule_1.createRule)({
     name: 'no-unused-props',
     meta: {
@@ -13,7 +16,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            unusedProp: 'Prop "{{propName}}" is defined in the Props type but not used in the component. Either use the prop in your component or remove it from the Props type. If you need to forward all props, use a rest spread operator: `const MyComponent = ({ usedProp, ...rest }: Props) => ...`',
+            unusedProp: 'Prop "{{propName}}" is declared in the component Props type but never used inside the component body. Unused props make the component API misleading: callers keep passing values that are ignored and reviewers assume behavior that is not implemented. Remove "{{propName}}" from the Props type, consume it in the component, or forward it with a rest spread (e.g., `const MyComponent = ({ usedProp, ...rest }: Props) => <Child {...rest} />`).',
         },
         fixable: 'code',
     },
@@ -22,8 +25,16 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
         const filename = context.filename ??
             context.getFilename();
         const ruleSettings = (context.settings && context.settings['no-unused-props']) ?? {};
-        const reactLikeExtensions = (ruleSettings.reactLikeExtensions ??
-            ['.tsx']).map((ext) => ext.toLowerCase());
+        const normalizeExtension = (ext) => {
+            const trimmed = ext.trim().toLowerCase();
+            if (!trimmed) {
+                return null;
+            }
+            return trimmed.startsWith('.') ? trimmed : `.${trimmed}`;
+        };
+        const reactLikeExtensions = Array.from(new Set((ruleSettings.reactLikeExtensions ?? ['.tsx'])
+            .map(normalizeExtension)
+            .filter((ext) => Boolean(ext))));
         const fileExtension = filename.includes('.')
             ? filename.slice(filename.lastIndexOf('.')).toLowerCase()
             : '';
@@ -43,14 +54,43 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
             'InstanceType',
             'ThisType',
         ]);
+        // Marks spread types whose members cannot be enumerated so unknown used props
+        // can still count as "using something" from the imported/spread type.
+        const UNKNOWN_SPREAD_PROP = '__unknown_spread_prop__';
+        const markUnknownSpreadType = (spreadTypeProps, spreadTypeName) => {
+            spreadTypeProps[spreadTypeName] ??= [];
+            if (!spreadTypeProps[spreadTypeName].includes(UNKNOWN_SPREAD_PROP)) {
+                spreadTypeProps[spreadTypeName].push(UNKNOWN_SPREAD_PROP);
+            }
+        };
+        const isTypeAliasDeclaration = (node) => node?.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration;
+        const findTypeAliasDeclaration = (typeName) => {
+            let scope = context.getScope();
+            while (scope) {
+                const variable = scope.set?.get(typeName) ??
+                    scope.variables.find((v) => v.name === typeName);
+                if (variable) {
+                    const typeAliasDef = variable.defs.find((def) => def.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration);
+                    const typeAliasNode = typeAliasDef?.node;
+                    if (isTypeAliasDeclaration(typeAliasNode)) {
+                        return typeAliasNode;
+                    }
+                }
+                scope = scope.upper;
+            }
+            return null;
+        };
         const propsTypes = new Map();
-        // Track which spread types have been used in a component
-        const usedSpreadTypes = new Map();
+        const componentToReferencedSpreadTypeNames = new Map();
+        const spreadTypeToPropNames = new Map();
+        const processingTypeAliases = new Set();
         const componentsToCheck = [];
         let currentComponent = null;
         const clearState = () => {
             propsTypes.clear();
-            usedSpreadTypes.clear();
+            componentToReferencedSpreadTypeNames.clear();
+            spreadTypeToPropNames.clear();
+            processingTypeAliases.clear();
             componentsToCheck.length = 0;
             currentComponent = null;
         };
@@ -66,19 +106,44 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
             }
             return false;
         };
-        const isAnyPropFromSpreadTypeUsed = (spreadTypeName, used) => {
-            const spreadTypeProps = usedSpreadTypes.get(spreadTypeName);
-            if (!spreadTypeProps) {
+        const isTSParenthesizedType = (node) => node.type === PAREN_TYPE &&
+            node.typeAnnotation != null;
+        const getStaticPropName = (key) => {
+            if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return key.name;
+            }
+            if (key.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof key.value === 'string') {
+                return key.value;
+            }
+            return null;
+        };
+        const isAnyPropFromSpreadTypeUsed = (spreadTypeName, used, knownProps) => {
+            const spreadTypeProps = spreadTypeToPropNames.get(spreadTypeName);
+            if (!spreadTypeProps || spreadTypeProps.size === 0) {
                 return false;
             }
+            if (spreadTypeProps.has(UNKNOWN_SPREAD_PROP)) {
+                for (const usedProp of used) {
+                    if (usedProp.startsWith('...')) {
+                        continue;
+                    }
+                    if (!knownProps.has(usedProp)) {
+                        return true;
+                    }
+                }
+            }
             for (const spreadProp of spreadTypeProps) {
+                if (spreadProp === UNKNOWN_SPREAD_PROP) {
+                    continue;
+                }
                 if (used.has(spreadProp)) {
                     return true;
                 }
             }
             return false;
         };
-        const shouldSkipSpreadType = (prop, hasRestSpread, used) => {
+        const shouldSkipSpreadType = (prop, hasRestSpread, used, knownProps) => {
             if (hasRestSpread) {
                 return true;
             }
@@ -86,16 +151,18 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
             if (UTILITY_TYPES.has(spreadTypeName)) {
                 return true;
             }
-            return isAnyPropFromSpreadTypeUsed(spreadTypeName, used);
+            return isAnyPropFromSpreadTypeUsed(spreadTypeName, used, knownProps);
         };
         const shouldSkipPropFromSpreadType = (prop, currentTypeName, used) => {
-            for (const [spreadType, props] of usedSpreadTypes.entries()) {
-                if (spreadType === currentTypeName)
-                    continue;
-                if (!props.has(prop)) {
+            const spreadTypes = componentToReferencedSpreadTypeNames.get(currentTypeName);
+            if (!spreadTypes)
+                return false;
+            for (const spreadType of spreadTypes) {
+                const spreadProps = spreadTypeToPropNames.get(spreadType);
+                if (!spreadProps || !spreadProps.has(prop)) {
                     continue;
                 }
-                for (const spreadProp of props) {
+                for (const spreadProp of spreadProps) {
                     if (used.has(spreadProp)) {
                         return true;
                     }
@@ -109,6 +176,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                 return;
             }
             const hasRestSpread = hasRestSpreadUsage(used, restUsed);
+            const knownProps = new Set(Object.keys(propsType));
             Object.keys(propsType).forEach((prop) => {
                 if (!used.has(prop)) {
                     // For imported types (props that start with '...'), only report if there's no rest spread operator
@@ -123,7 +191,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                         shouldReport = false;
                     }
                     else if (prop.startsWith('...')) {
-                        shouldReport = !shouldSkipSpreadType(prop, hasRestSpread, used);
+                        shouldReport = !shouldSkipSpreadType(prop, hasRestSpread, used, knownProps);
                     }
                     else {
                         shouldReport = !shouldSkipPropFromSpreadType(prop, typeName, used);
@@ -140,62 +208,206 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
         };
         return {
             TSTypeAliasDeclaration(node) {
-                if (node.id.name.endsWith('Props')) {
+                if (!node.id.name.endsWith('Props')) {
+                    return;
+                }
+                if (processingTypeAliases.has(node.id.name)) {
+                    return;
+                }
+                processingTypeAliases.add(node.id.name);
+                try {
                     const props = {};
                     // Track which properties come from which spread type
                     const spreadTypeProps = {};
-                    const addBaseTypeProps = (typeNode, shouldInclude = () => true) => {
-                        if (typeNode.type !== utils_1.AST_NODE_TYPES.TSTypeLiteral) {
-                            return;
+                    const visitingTypeReferences = new Set();
+                    const scope = context.getScope();
+                    const withTypeVisitation = (visited, typeName, callback) => {
+                        if (visited.has(typeName)) {
+                            return null;
+                        }
+                        visited.add(typeName);
+                        try {
+                            return callback();
+                        }
+                        finally {
+                            visited.delete(typeName);
                         }
-                        typeNode.members.forEach((member) => {
-                            if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
-                                member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                shouldInclude(member.key.name)) {
-                                props[member.key.name] = member.key;
+                    };
+                    const addBaseTypeProps = (typeNode, shouldInclude = () => true) => {
+                        // Tracks type identifiers while descending to avoid infinite recursion on
+                        // self-referential or mutually recursive type aliases; names are removed
+                        // in the finally block so parallel branches still run.
+                        const visitingTypeNames = new Set();
+                        const visit = (node) => {
+                            if (isTSParenthesizedType(node)) {
+                                return visit(node.typeAnnotation);
                             }
-                        });
+                            switch (node.type) {
+                                case utils_1.AST_NODE_TYPES.TSTypeLiteral: {
+                                    let added = false;
+                                    node.members.forEach((member) => {
+                                        if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                                            return;
+                                        }
+                                        const propName = getStaticPropName(member.key);
+                                        if (propName && shouldInclude(propName)) {
+                                            props[propName] = member.key;
+                                            added = true;
+                                        }
+                                    });
+                                    return added;
+                                }
+                                case utils_1.AST_NODE_TYPES.TSIntersectionType:
+                                case utils_1.AST_NODE_TYPES.TSUnionType: {
+                                    let added = false;
+                                    node.types.forEach((child) => {
+                                        if (visit(child)) {
+                                            added = true;
+                                        }
+                                    });
+                                    return added;
+                                }
+                                case utils_1.AST_NODE_TYPES.TSTypeReference: {
+                                    if (node.typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                                        return false;
+                                    }
+                                    const typeIdentifier = node.typeName;
+                                    return (withTypeVisitation(visitingTypeNames, typeIdentifier.name, () => {
+                                        const typeAliasNode = findTypeAliasDeclaration(typeIdentifier.name);
+                                        return typeAliasNode
+                                            ? visit(typeAliasNode.typeAnnotation)
+                                            : false;
+                                    }) ?? false);
+                                }
+                                default:
+                                    return false;
+                            }
+                        };
+                        return visit(typeNode);
                     };
-                    const handleOmitType = (baseType, omittedProps) => {
-                        if (baseType.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
-                            baseType.typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
-                            return;
-                        }
-                        const baseTypeName = baseType.typeName.name;
+                    const handleOmitType = (baseType, omittedProps, currentScope) => {
+                        const baseTypeName = baseType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            baseType.typeName.type === utils_1.AST_NODE_TYPES.Identifier
+                            ? baseType.typeName.name
+                            : null;
+                        const sourceCode = context.getSourceCode();
+                        const baseTypeRefText = baseType.type === utils_1.AST_NODE_TYPES.TSTypeReference
+                            ? sourceCode.getText(baseType.typeName)
+                            : null;
+                        const spreadKey = baseTypeName ?? baseTypeRefText;
+                        const fallbackSpreadKey = spreadKey ?? sourceCode.getText(baseType);
+                        const recordSpreadMarker = () => {
+                            const markerKey = fallbackSpreadKey;
+                            if (!markerKey) {
+                                return;
+                            }
+                            props[`...${markerKey}`] =
+                                baseType.type === utils_1.AST_NODE_TYPES.TSTypeReference
+                                    ? baseType.typeName
+                                    : baseType;
+                            markUnknownSpreadType(spreadTypeProps, markerKey);
+                        };
                         const omittedPropNames = new Set();
+                        let canComputeOmittedProps = false;
                         if (omittedProps.type === utils_1.AST_NODE_TYPES.TSUnionType) {
-                            omittedProps.types.forEach((type) => {
-                                if (type.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
-                                    type.literal.type === utils_1.AST_NODE_TYPES.Literal &&
-                                    typeof type.literal.value === 'string') {
-                                    omittedPropNames.add(type.literal.value);
-                                }
-                            });
+                            canComputeOmittedProps = omittedProps.types.every((type) => type.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+                                type.literal.type === utils_1.AST_NODE_TYPES.Literal &&
+                                typeof type.literal.value === 'string');
+                            if (canComputeOmittedProps) {
+                                omittedProps.types.forEach((type) => {
+                                    if (type.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+                                        type.literal.type === utils_1.AST_NODE_TYPES.Literal &&
+                                        typeof type.literal.value === 'string') {
+                                        omittedPropNames.add(type.literal.value);
+                                    }
+                                });
+                            }
                         }
                         else if (omittedProps.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
                             omittedProps.literal.type === utils_1.AST_NODE_TYPES.Literal &&
                             typeof omittedProps.literal.value === 'string') {
+                            canComputeOmittedProps = true;
                             omittedPropNames.add(omittedProps.literal.value);
                         }
-                        const scope = context.getScope();
-                        const variable = scope.variables.find((v) => v.name === baseTypeName);
-                        if (variable &&
-                            variable.defs[0]?.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
-                            addBaseTypeProps(variable.defs[0].node.typeAnnotation, (name) => !omittedPropNames.has(name));
+                        if (!canComputeOmittedProps) {
+                            if (spreadKey) {
+                                recordSpreadMarker();
+                                return;
+                            }
+                            const added = addBaseTypeProps(baseType);
+                            if (!added) {
+                                recordSpreadMarker();
+                            }
+                            return;
                         }
-                        else {
-                            props[`...${baseTypeName}`] = baseType.typeName;
-                            if (!spreadTypeProps[baseTypeName]) {
-                                spreadTypeProps[baseTypeName] = [];
+                        const shouldInclude = (name) => !omittedPropNames.has(name);
+                        let added = false;
+                        if (currentScope && baseTypeName) {
+                            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(currentScope, baseTypeName);
+                            const definitionNode = variable?.defs[0]?.node;
+                            if (definitionNode?.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                                added = addBaseTypeProps(definitionNode.typeAnnotation, shouldInclude);
                             }
+                            else if (definitionNode?.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                                added = addInterfaceProps(definitionNode, currentScope, shouldInclude);
+                            }
+                        }
+                        if (!added) {
+                            added = addBaseTypeProps(baseType, shouldInclude);
                         }
+                        if (added) {
+                            return;
+                        }
+                        recordSpreadMarker();
                     };
-                    function extractProps(typeNode) {
+                    const addPropsFromMembers = (members, shouldInclude = () => true) => {
+                        let added = false;
+                        for (const member of members) {
+                            if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                                member.type !== utils_1.AST_NODE_TYPES.TSMethodSignature) {
+                                continue;
+                            }
+                            const propName = getStaticPropName(member.key);
+                            if (!propName || !shouldInclude(propName)) {
+                                continue;
+                            }
+                            props[propName] = member.key;
+                            added = true;
+                        }
+                        return added;
+                    };
+                    const addInterfaceProps = (declaration, currentScope, shouldInclude = () => true, visitingInterfaces = new Set()) => {
+                        return (withTypeVisitation(visitingInterfaces, declaration.id.name, () => {
+                            let added = addPropsFromMembers(declaration.body.body, shouldInclude);
+                            declaration.extends?.forEach((extension) => {
+                                if (extension.expression.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                    extension.expression.name) {
+                                    const parentVariable = ASTHelpers_1.ASTHelpers.findVariableInScope(currentScope, extension.expression.name);
+                                    const parentDef = parentVariable?.defs[0]?.node;
+                                    if (parentDef?.type ===
+                                        utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                                        added =
+                                            addInterfaceProps(parentDef, currentScope, shouldInclude, visitingInterfaces) || added;
+                                    }
+                                    else if (parentDef?.type ===
+                                        utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                                        added =
+                                            addBaseTypeProps(parentDef.typeAnnotation, shouldInclude) || added;
+                                    }
+                                }
+                            });
+                            return added;
+                        }) ?? false);
+                    };
+                    function extractProps(typeNode, currentScope) {
                         if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
                             typeNode.members.forEach((member) => {
-                                if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
-                                    member.key.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                    props[member.key.name] = member.key;
+                                if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                                    return;
+                                }
+                                const propName = getStaticPropName(member.key);
+                                if (propName) {
+                                    props[propName] = member.key;
                                 }
                             });
                         }
@@ -246,16 +458,15 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                             type.typeParameters.params.length === 2) {
                                             // Handle Omit utility type in intersection
                                             const [baseType, omittedProps] = type.typeParameters.params;
-                                            handleOmitType(baseType, omittedProps);
+                                            handleOmitType(baseType, omittedProps, currentScope);
                                         }
                                         else {
                                             // For referenced types in intersections, we need to find their type declaration
-                                            const scope = context.getScope();
-                                            const variable = scope.variables.find((v) => v.name === typeName.name);
-                                            if (variable &&
-                                                variable.defs[0]?.node.type ===
-                                                    utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
-                                                extractProps(variable.defs[0].node.typeAnnotation);
+                                            const typeAliasNode = findTypeAliasDeclaration(typeName.name);
+                                            if (typeAliasNode) {
+                                                withTypeVisitation(visitingTypeReferences, typeName.name, () => {
+                                                    extractProps(typeAliasNode.typeAnnotation, currentScope);
+                                                });
                                             }
                                             else {
                                                 // If we can't find the type declaration, it's likely an imported type
@@ -264,15 +475,13 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                                 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] = [];
-                                                }
+                                                markUnknownSpreadType(spreadTypeProps, spreadTypeName);
                                             }
                                         }
                                     }
                                 }
                                 else {
-                                    extractProps(type);
+                                    extractProps(type, currentScope);
                                 }
                             });
                         }
@@ -328,7 +537,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                     typeNode.typeParameters.params.length === 2) {
                                     // Handle Omit<T, K> utility type
                                     const [baseType, omittedProps] = typeNode.typeParameters.params;
-                                    handleOmitType(baseType, omittedProps);
+                                    handleOmitType(baseType, omittedProps, currentScope);
                                 }
                                 else if (
                                 // Handle other utility types like Required, Partial, etc.
@@ -339,21 +548,19 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                     if (baseType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
                                         baseType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
                                         const baseTypeName = baseType.typeName.name;
-                                        // Find the base type definition
-                                        const scope = context.getScope();
-                                        const variable = scope.variables.find((v) => v.name === baseTypeName);
-                                        if (variable &&
-                                            variable.defs[0]?.node.type ===
-                                                utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                                        const typeAliasNode = findTypeAliasDeclaration(baseTypeName);
+                                        if (typeAliasNode) {
                                             // For Partial<T>, Required<T>, etc., add all properties from the base type
-                                            addBaseTypeProps(variable.defs[0].node.typeAnnotation);
+                                            const added = addBaseTypeProps(typeAliasNode.typeAnnotation);
+                                            if (!added) {
+                                                props[`...${baseTypeName}`] = baseType.typeName;
+                                                markUnknownSpreadType(spreadTypeProps, baseTypeName);
+                                            }
                                         }
                                         else {
                                             // If we can't find the base type definition, treat it as a spread type
                                             props[`...${baseTypeName}`] = baseType.typeName;
-                                            if (!spreadTypeProps[baseTypeName]) {
-                                                spreadTypeProps[baseTypeName] = [];
-                                            }
+                                            markUnknownSpreadType(spreadTypeProps, baseTypeName);
                                         }
                                     }
                                 }
@@ -363,29 +570,24 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                     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] = [];
-                                    }
+                                    markUnknownSpreadType(spreadTypeProps, spreadTypeName);
                                 }
                             }
                         }
                     }
-                    extractProps(node.typeAnnotation);
+                    extractProps(node.typeAnnotation, scope);
                     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
+                    componentToReferencedSpreadTypeNames.set(typeName, new Set(Object.keys(spreadTypeProps)));
                     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);
+                        const spreadTypeSet = spreadTypeToPropNames.get(spreadType) ?? new Set();
+                        spreadTypeToPropNames.set(spreadType, spreadTypeSet);
                         propNames.forEach((prop) => spreadTypeSet.add(prop));
                     }
                 }
+                finally {
+                    processingTypeAliases.delete(node.id.name);
+                }
             },
             VariableDeclaration(node) {
                 if (node.declarations.length === 1) {
@@ -402,9 +604,11 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                 const used = new Set();
                                 let restUsed = false;
                                 param.properties.forEach((prop) => {
-                                    if (prop.type === utils_1.AST_NODE_TYPES.Property &&
-                                        prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                        used.add(prop.key.name);
+                                    if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                                        const propName = getStaticPropName(prop.key);
+                                        if (propName) {
+                                            used.add(propName);
+                                        }
                                     }
                                     else if (prop.type === utils_1.AST_NODE_TYPES.RestElement &&
                                         prop.argument.type === utils_1.AST_NODE_TYPES.Identifier) {

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

@@ -17,7 +17,7 @@ exports.noUnusedUseState = createRule({
         },
         fixable: 'code',
         messages: {
-            unusedUseState: 'The state variable is ignored. Remove the unused useState hook.',
+            unusedUseState: 'State value "{{stateName}}" from useState is discarded. React still allocates state and re-renders for a value you never read, which misleads readers into thinking the component depends on that state. Remove the useState pair or switch to a ref/derived value when you only need the setter-style side effect.',
         },
         schema: [],
     },
@@ -41,12 +41,16 @@ exports.noUnusedUseState = createRule({
                                 utils_1.TSESTree.AST_NODE_TYPES.Identifier &&
                             (arrayPattern.elements[0].name === '_' ||
                                 arrayPattern.elements[0].name.startsWith('_'))) {
+                            const stateIdentifier = arrayPattern.elements[0];
                             context.report({
                                 node,
                                 messageId: 'unusedUseState',
+                                data: {
+                                    stateName: stateIdentifier.name,
+                                },
                                 fix: (fixer) => {
                                     // Remove the entire useState declaration
-                                    const sourceCode = context.getSourceCode();
+                                    const sourceCode = context.sourceCode;
                                     const parentStatement = node.parent;
                                     if (parentStatement &&
                                         parentStatement.type ===

package/lib/rules/no-useless-fragment.js

@@ -1,16 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUselessFragment = void 0;
+/**
+ * Normalizes JSX child node types into short descriptors used inside lint messages.
+ * Keeps message phrasing consistent regardless of the specific child node shape.
+ * @param child - The JSX child node to describe.
+ * @returns Human-readable descriptor for the child type used in lint messages.
+ */
+const describeChild = (child) => {
+    switch (child.type) {
+        case 'JSXElement':
+            return 'JSX element';
+        case 'JSXFragment':
+            return 'fragment';
+        case 'JSXExpressionContainer':
+            return 'expression result';
+        case 'JSXText':
+            return 'text node';
+        case 'JSXSpreadChild':
+            return 'spread child';
+        default:
+            return 'child node';
+    }
+};
 exports.noUselessFragment = {
     create(context) {
         return {
             JSXFragment(node) {
                 if (node.children.length === 1) {
+                    const [child] = node.children;
                     context.report({
                         node,
                         messageId: 'noUselessFragment',
+                        data: {
+                            childKind: describeChild(child),
+                        },
                         fix(fixer) {
-                            const sourceCode = context.getSourceCode();
+                            const sourceCode = context.sourceCode;
                             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                             const openingFragment = sourceCode.getFirstToken(node);
                             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -38,7 +64,7 @@ exports.noUselessFragment = {
             recommended: 'error',
         },
         messages: {
-            noUselessFragment: 'React fragment is unnecessary when wrapping a single child. Instead of `<>{"text"}</> or <Fragment>{"text"}</Fragment>`, use just `{"text"}`. Fragments are only needed when returning multiple elements.',
+            noUselessFragment: 'React fragment wraps a single {{childKind}} and does not provide grouping. Fragments exist to wrap multiple siblings; leaving this fragment adds extra syntax and a React tree node without changing the rendered output. Remove the fragment and return the child directly.',
         },
         schema: [],
         fixable: 'code',

package/lib/rules/no-useless-usememo-primitives.d.ts

@@ -0,0 +1,9 @@
+type Options = [
+    {
+        ignoreCallExpressions?: boolean;
+        ignoreSymbol?: boolean;
+        tsOnly?: boolean;
+    }
+];
+export declare const noUselessUsememoPrimitives: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"uselessUseMemoPrimitive", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default noUselessUsememoPrimitives;