@blumintinc/eslint-plugin-blumint 1.13.0 → 1.14.0

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

@@ -97,13 +97,40 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
             },
         ],
         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.',
+            noTypeAssertionReturns: `What's wrong: Return value uses a type assertion to "{{assertedType}}", which bypasses TypeScript checks. ` +
+                `→ Why it matters: Casts can hide missing or invalid data and let unsafe values reach callers without compile-time errors. ` +
+                `→ How to fix: Create a typed variable or add a narrowing step before returning so the value is validated by the type system instead of forced with a cast.`,
+            useExplicitVariable: `What's wrong: Return type "{{returnType}}" is declared while returning an unchecked expression, so TypeScript trusts the annotation instead of validating the actual value. ` +
+                `→ Why it matters: This hides mismatches between implementation and contract, letting incorrect return values propagate without type errors. ` +
+                `→ How to fix: Assign the expression to a typed variable or narrow it first, then return that variable so TypeScript can verify it against the declared return type.`,
         },
     },
     defaultOptions: [defaultOptions],
     create(context, [options]) {
         const mergedOptions = { ...defaultOptions, ...options };
+        const sourceCode = context.getSourceCode();
+        function getTypeText(typeNode, fallback) {
+            const text = typeNode ? sourceCode.getText(typeNode).trim() : '';
+            return text || fallback;
+        }
+        function reportTypeAssertion(node) {
+            context.report({
+                node,
+                messageId: 'noTypeAssertionReturns',
+                data: {
+                    assertedType: getTypeText(node.typeAnnotation, 'the asserted type'),
+                },
+            });
+        }
+        function reportReturnTypeAnnotation(typeAnnotation) {
+            context.report({
+                node: typeAnnotation,
+                messageId: 'useExplicitVariable',
+                data: {
+                    returnType: getTypeText(typeAnnotation.typeAnnotation, 'the declared return type'),
+                },
+            });
+        }
         /**
          * Checks if a node is inside a JSX attribute or object property (which could be JSX props)
          */
@@ -202,7 +229,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
         /**
          * Check if the current file is a .f.ts file
          */
-        function isFunctionFile(context) {
+        function isFunctionFile() {
             const filename = context.getFilename();
             return filename.endsWith('.f.ts');
         }
@@ -213,7 +240,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
             if (!node.returnType)
                 return;
             // Skip checking return types in .f.ts files
-            if (isFunctionFile(context)) {
+            if (isFunctionFile()) {
                 return;
             }
             // Allow type predicates if configured
@@ -224,10 +251,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
             // If type predicates are not allowed, report them
             if (!mergedOptions.allowTypePredicates &&
                 isTypePredicate(node.returnType)) {
-                context.report({
-                    node: node.returnType,
-                    messageId: 'useExplicitVariable',
-                });
+                reportReturnTypeAnnotation(node.returnType);
                 return;
             }
             // Check if the function has a return statement with a direct value (not a variable)
@@ -244,10 +268,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                         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',
-                            });
+                            reportReturnTypeAnnotation(node.returnType);
                             break;
                         }
                     }
@@ -267,23 +288,14 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                     }
                     // 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',
-                        });
+                        reportTypeAssertion(node.argument);
                         return;
                     }
-                    context.report({
-                        node: node.argument,
-                        messageId: 'noTypeAssertionReturns',
-                    });
+                    reportTypeAssertion(node.argument);
                 }
                 // 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',
-                    });
+                    reportTypeAssertion(node.argument);
                 }
             },
             // Check functions with explicit return types
@@ -301,7 +313,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                     // Check for explicit return type
                     if (node.returnType) {
                         // Skip checking return types in .f.ts files
-                        if (isFunctionFile(context)) {
+                        if (isFunctionFile()) {
                             return;
                         }
                         // Allow type predicates if configured
@@ -312,19 +324,13 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                         // If type predicates are not allowed, report them
                         if (!mergedOptions.allowTypePredicates &&
                             isTypePredicate(node.returnType)) {
-                            context.report({
-                                node: node.returnType,
-                                messageId: 'useExplicitVariable',
-                            });
+                            reportReturnTypeAnnotation(node.returnType);
                             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',
-                            });
+                            reportReturnTypeAnnotation(node.returnType);
                         }
                     }
                     // Check for type assertions in the body
@@ -333,16 +339,10 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                         if (mergedOptions.allowAsConst && isAsConstAssertion(node.body)) {
                             return;
                         }
-                        context.report({
-                            node: node.body,
-                            messageId: 'noTypeAssertionReturns',
-                        });
+                        reportTypeAssertion(node.body);
                     }
                     else if (node.body.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
-                        context.report({
-                            node: node.body,
-                            messageId: 'noTypeAssertionReturns',
-                        });
+                        reportTypeAssertion(node.body);
                     }
                 }
                 else if (node.returnType) {
@@ -365,10 +365,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                     return;
                 }
                 // For standalone type assertions in expressions
-                context.report({
-                    node,
-                    messageId: 'noTypeAssertionReturns',
-                });
+                reportTypeAssertion(node);
             },
             // Check for type assertions using angle bracket syntax
             TSTypeAssertion(node) {
@@ -377,10 +374,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                     return;
                 }
                 // For standalone type assertions in expressions
-                context.report({
-                    node,
-                    messageId: 'noTypeAssertionReturns',
-                });
+                reportTypeAssertion(node);
             },
         };
     },

package/lib/rules/no-undefined-null-passthrough.js

@@ -2,18 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUndefinedNullPassthrough = void 0;
 const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
 exports.noUndefinedNullPassthrough = (0, createRule_1.createRule)({
     create(context) {
         return {
             FunctionDeclaration(node) {
-                // Skip functions with no parameters
-                if (node.params.length === 0) {
-                    return;
-                }
-                // Skip React hooks (functions starting with 'use')
-                if (node.id &&
-                    node.id.type === 'Identifier' &&
-                    node.id.name.startsWith('use')) {
+                if (shouldSkipFunction(node)) {
                     return;
                 }
                 // For functions with exactly one parameter, check if it's passing through null/undefined
@@ -26,16 +20,7 @@ exports.noUndefinedNullPassthrough = (0, createRule_1.createRule)({
                 }
             },
             ArrowFunctionExpression(node) {
-                // Skip functions with no parameters
-                if (node.params.length === 0) {
-                    return;
-                }
-                // Skip if the function is part of a variable declaration that starts with 'use' (React hook)
-                const parent = node.parent;
-                if (parent &&
-                    parent.type === 'VariableDeclarator' &&
-                    parent.id.type === 'Identifier' &&
-                    parent.id.name.startsWith('use')) {
+                if (shouldSkipFunction(node)) {
                     return;
                 }
                 // For arrow functions with block body
@@ -54,16 +39,7 @@ exports.noUndefinedNullPassthrough = (0, createRule_1.createRule)({
                 }
             },
             FunctionExpression(node) {
-                // Skip functions with no parameters
-                if (node.params.length === 0) {
-                    return;
-                }
-                // Skip if the function is part of a variable declaration that starts with 'use' (React hook)
-                const parent = node.parent;
-                if (parent &&
-                    parent.type === 'VariableDeclarator' &&
-                    parent.id.type === 'Identifier' &&
-                    parent.id.name.startsWith('use')) {
+                if (shouldSkipFunction(node)) {
                     return;
                 }
                 // For functions with exactly one parameter, check if it's passing through null/undefined
@@ -86,7 +62,7 @@ exports.noUndefinedNullPassthrough = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            unexpected: 'Avoid functions that return undefined or null when their single argument is undefined or null. Move the null/undefined check to the caller instead.',
+            unexpected: 'Function returns null or undefined when "{{paramName}}" is nullish, which just passes the missing value to callers. This hides where validation belongs, delays failures until runtime as null values propagate unpredictably, and forces every caller to add defensive branching—making bugs and debugging more likely. Validate the argument before calling (throw an error if it is required) or return a concrete fallback (for example, an empty array or default object) so this function always provides a meaningful result.',
         },
     },
     defaultOptions: [],
@@ -126,6 +102,7 @@ function checkFunctionBody(body, param, context) {
                                 context.report({
                                     node: statement,
                                     messageId: 'unexpected',
+                                    data: { paramName },
                                 });
                             }
                             return;
@@ -142,6 +119,7 @@ function checkFunctionBody(body, param, context) {
                         context.report({
                             node: statement,
                             messageId: 'unexpected',
+                            data: { paramName },
                         });
                     }
                     return;
@@ -254,6 +232,7 @@ function checkImplicitReturn(node, context) {
             context.report({
                 node,
                 messageId: 'unexpected',
+                data: { paramName },
             });
         }
     }
@@ -264,6 +243,7 @@ function checkImplicitReturn(node, context) {
             context.report({
                 node,
                 messageId: 'unexpected',
+                data: { paramName },
             });
         }
     }
@@ -272,6 +252,7 @@ function checkImplicitReturn(node, context) {
         context.report({
             node,
             messageId: 'unexpected',
+            data: { paramName },
         });
     }
 }
@@ -360,8 +341,8 @@ function checkFunctionBodyForEarlyReturns(body, params, context) {
         if (statement.type === 'IfStatement') {
             const test = statement.test;
             // Check if the test is checking any parameter for null/undefined
-            const isParameterCheck = paramNames.some((paramName) => isNullUndefinedCheck(test, paramName));
-            if (isParameterCheck) {
+            const matchedParam = paramNames.find((paramName) => isNullUndefinedCheck(test, paramName));
+            if (matchedParam) {
                 // Check if the consequent is a block statement with a return
                 if (statement.consequent.type === 'BlockStatement') {
                     for (const consequentStmt of statement.consequent.body) {
@@ -374,6 +355,7 @@ function checkFunctionBodyForEarlyReturns(body, params, context) {
                                 context.report({
                                     node: statement,
                                     messageId: 'unexpected',
+                                    data: { paramName: matchedParam },
                                 });
                             }
                             return;
@@ -390,6 +372,7 @@ function checkFunctionBodyForEarlyReturns(body, params, context) {
                         context.report({
                             node: statement,
                             messageId: 'unexpected',
+                            data: { paramName: matchedParam },
                         });
                     }
                     return;
@@ -398,4 +381,51 @@ function checkFunctionBodyForEarlyReturns(body, params, context) {
         }
     }
 }
+function shouldSkipFunction(node) {
+    // Skip functions with no parameters
+    if (node.params.length === 0) {
+        return true;
+    }
+    // Skip functions with any parameter typed as 'unknown'
+    if (node.params.some(isUnknownParameter)) {
+        return true;
+    }
+    // Skip React hooks (functions starting with 'use')
+    let name;
+    if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+        name = node.id?.name;
+    }
+    else {
+        const parent = node.parent;
+        if (parent &&
+            parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+            parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+            name = parent.id.name;
+        }
+    }
+    if (name?.startsWith('use')) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Exempts type-narrowing functions from the rule by checking for 'unknown' parameters.
+ * These functions often narrow from 'unknown' and return null/undefined for invalid types,
+ * which is a valid pattern.
+ *
+ * TODO: Handle edge cases like rest parameters (...args: unknown[]),
+ * destructured parameters ({ x }: unknown), and array patterns ([a]: unknown).
+ */
+function isUnknownParameter(param) {
+    if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return (param.typeAnnotation?.typeAnnotation.type ===
+            utils_1.AST_NODE_TYPES.TSUnknownKeyword);
+    }
+    if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+        param.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return (param.left.typeAnnotation?.typeAnnotation.type ===
+            utils_1.AST_NODE_TYPES.TSUnknownKeyword);
+    }
+    return false;
+}
 //# sourceMappingURL=no-undefined-null-passthrough.js.map

package/lib/rules/no-unmemoized-memo-without-props.d.ts

@@ -0,0 +1,8 @@
+type Options = [
+    {
+        ignoreHooks?: string[];
+        ignoreHocs?: string[];
+    }
+];
+export declare const noUnmemoizedMemoWithoutProps: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unnecessaryMemoWithoutProps", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};