@blumintinc/eslint-plugin-blumint 1.7.3 → 1.8.1

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

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noTypeAssertionReturns = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const defaultOptions = {
+    allowAsConst: true,
+    allowTypePredicates: true,
+};
+/**
+ * Checks if a type assertion is 'as const'
+ */
+function isAsConstAssertion(node) {
+    const typeAnnotation = node.typeAnnotation;
+    return (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+        typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+        typeAnnotation.typeName.name === 'const');
+}
+/**
+ * Checks if a node is a type predicate (using 'is' keyword)
+ */
+function isTypePredicate(node) {
+    return node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypePredicate;
+}
+exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
+    name: 'no-type-assertion-returns',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce typing variables before returning them, rather than using type assertions or explicit return types',
+            recommended: 'error',
+            requiresTypeChecking: false,
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowAsConst: { type: 'boolean' },
+                    allowTypePredicates: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noTypeAssertionReturns: 'Type assertions in return statements are not allowed. Type the variable explicitly before returning it.',
+            useExplicitVariable: 'Explicit return type annotations are not allowed. Type the variable explicitly before returning it.',
+        },
+    },
+    defaultOptions: [defaultOptions],
+    create(context, [options]) {
+        const mergedOptions = { ...defaultOptions, ...options };
+        return {
+            // Check for return statements with type assertions
+            ReturnStatement(node) {
+                if (!node.argument)
+                    return;
+                // Check for type assertions using 'as' keyword
+                if (node.argument.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                    // Allow 'as const' assertions if configured
+                    if (mergedOptions.allowAsConst && isAsConstAssertion(node.argument)) {
+                        return;
+                    }
+                    // For nested type assertions, only report the outermost one
+                    if (node.argument.expression.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                        context.report({
+                            node: node.argument,
+                            messageId: 'noTypeAssertionReturns',
+                        });
+                        return;
+                    }
+                    context.report({
+                        node: node.argument,
+                        messageId: 'noTypeAssertionReturns',
+                    });
+                }
+                // Check for type assertions using angle bracket syntax
+                if (node.argument.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+                    context.report({
+                        node: node.argument,
+                        messageId: 'noTypeAssertionReturns',
+                    });
+                }
+            },
+            // 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;
+                            }
+                        }
+                    }
+                }
+            },
+            // 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;
+                            }
+                        }
+                    }
+                }
+            },
+            // Check arrow functions
+            ArrowFunctionExpression(node) {
+                // For arrow functions with expression bodies (no block)
+                if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                    // Check for explicit return type
+                    if (node.returnType) {
+                        // 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;
+                        }
+                        // If returning an object literal with explicit return type, report it
+                        if (node.body.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+                            node.body.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                            context.report({
+                                node: node.returnType,
+                                messageId: 'useExplicitVariable',
+                            });
+                        }
+                    }
+                    // Check for type assertions in the body
+                    if (node.body.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                        // Allow 'as const' assertions if configured
+                        if (mergedOptions.allowAsConst && isAsConstAssertion(node.body)) {
+                            return;
+                        }
+                        context.report({
+                            node: node.body,
+                            messageId: 'noTypeAssertionReturns',
+                        });
+                    }
+                    else if (node.body.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+                        context.report({
+                            node: node.body,
+                            messageId: 'noTypeAssertionReturns',
+                        });
+                    }
+                }
+                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;
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            // Check for array methods with type assertions
+            CallExpression() {
+                // Skip this check as we'll handle it in the TSAsExpression and TSTypeAssertion handlers
+            },
+            // Check for type assertions in expressions
+            TSAsExpression(node) {
+                // Allow 'as const' assertions if configured
+                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) {
+                    return;
+                }
+                // 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;
+                }
+                // For standalone type assertions in expressions
+                context.report({
+                    node,
+                    messageId: 'noTypeAssertionReturns',
+                });
+            },
+            // 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) {
+                    return;
+                }
+                // 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;
+                }
+                // For standalone type assertions in expressions
+                context.report({
+                    node,
+                    messageId: 'noTypeAssertionReturns',
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-type-assertion-returns.js.map

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-unnecessary-verb-suffix.d.ts

@@ -0,0 +1 @@
+export declare const noUnnecessaryVerbSuffix: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unnecessaryVerbSuffix", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-unnecessary-verb-suffix.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnnecessaryVerbSuffix = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const COMMON_PREPOSITION_SUFFIXES = new Set([
+    // Basic prepositions
+    'From',
+    'For',
+    'With',
+    'To',
+    'By',
+    'In',
+    'On',
+    'At',
+    'Of',
+    // Directional prepositions
+    'Above',
+    'Below',
+    'Over',
+    'Under',
+    'Up',
+    'Down',
+    'Into',
+    'Onto',
+    'Out',
+    'Off',
+    'Through',
+    'Throughout',
+    'Across',
+    'Along',
+    'Around',
+    'Past',
+    // Temporal prepositions
+    'After',
+    'Before',
+    'During',
+    'Until',
+    'Till',
+    'Since',
+    'Within',
+    // Logical/causal prepositions
+    'Because',
+    'Despite',
+    'Instead',
+    'Via',
+    'Without',
+    'Versus',
+    'Vs',
+    // Comparative prepositions
+    'Than',
+    'Like',
+    'As',
+    // Compound prepositions
+    'According',
+    'Ahead',
+    'Apart',
+    'Aside',
+    'Away',
+    'Back',
+    'Forward',
+    'Backward',
+    'Inside',
+    'Outside',
+    'Together',
+    // Phrasal prepositions (common endings)
+    'About',
+    'Against',
+    'Among',
+    'Amongst',
+    'Beside',
+    'Besides',
+    'Between',
+    'Beyond',
+    'Concerning',
+    'Considering',
+    'Regarding',
+    'Respecting',
+    'Towards',
+    'Toward',
+    'Upon',
+    // Preposition-like adverbs
+    'Again',
+    'Already',
+    'Always',
+    'Ever',
+    'Never',
+    'Now',
+    'Soon',
+    'Then',
+    'There',
+    'Where',
+    'When',
+    'While',
+    // Programming-specific suffixes
+    'Async',
+    'Sync',
+]);
+exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
+    name: 'no-unnecessary-verb-suffix',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prevent unnecessary verb suffixes in function and method names',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            unnecessaryVerbSuffix: 'Unnecessary verb suffix "{{suffix}}" in function name. Consider using "{{suggestion}}" instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function checkFunctionName(node, name) {
+            if (!name)
+                return;
+            for (const suffix of COMMON_PREPOSITION_SUFFIXES) {
+                // Check if the name ends with the suffix
+                if (name.endsWith(suffix)) {
+                    // Make sure there's a verb before the suffix (camelCase format)
+                    // This regex checks for a verb pattern before the suffix
+                    // It looks for a word character followed by lowercase letters before the suffix
+                    const verbBeforeSuffixPattern = new RegExp(`\\w[a-z]+${suffix}$`);
+                    if (verbBeforeSuffixPattern.test(name)) {
+                        const suggestion = name.substring(0, name.length - suffix.length);
+                        // Skip if the suggestion would be empty or just a single character
+                        if (suggestion.length <= 1)
+                            continue;
+                        context.report({
+                            node,
+                            messageId: 'unnecessaryVerbSuffix',
+                            data: {
+                                suffix,
+                                suggestion,
+                            },
+                            fix(fixer) {
+                                if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                                    return fixer.replaceText(node.id, suggestion);
+                                }
+                                else if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                                    node.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                                    const parent = node.parent;
+                                    if (parent &&
+                                        (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                                            parent.type === utils_1.AST_NODE_TYPES.Property ||
+                                            parent.type === utils_1.AST_NODE_TYPES.MethodDefinition)) {
+                                        if ('key' in parent) {
+                                            return fixer.replaceText(parent.key, suggestion);
+                                        }
+                                        else if ('id' in parent && parent.id) {
+                                            return fixer.replaceText(parent.id, suggestion);
+                                        }
+                                    }
+                                }
+                                return null;
+                            },
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            FunctionDeclaration(node) {
+                if (node.id) {
+                    checkFunctionName(node, node.id.name);
+                }
+            },
+            VariableDeclarator(node) {
+                if (node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (node.init?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        node.init?.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    checkFunctionName(node.init, node.id.name);
+                }
+            },
+            MethodDefinition(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    checkFunctionName(node.value, node.key.name);
+                }
+            },
+            TSMethodSignature(node) {
+                // Handle interface method signatures
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    checkFunctionName(node, node.key.name);
+                }
+            },
+            Property(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (node.value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        node.value.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    checkFunctionName(node.value, node.key.name);
+                }
+            },
+            FunctionExpression(node) {
+                // Handle named function expressions
+                if (node.id) {
+                    checkFunctionName(node, node.id.name);
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-unnecessary-verb-suffix.js.map

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

@@ -168,11 +168,16 @@ 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('...'));
+                                if (!prop.startsWith('...') || !hasRestSpread) {
+                                    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;
+}>;