@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

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

@@ -2,58 +2,54 @@
 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) {
-                // Only apply to functions with exactly one parameter
-                if (node.params.length !== 1) {
+                if (shouldSkipFunction(node)) {
                     return;
                 }
-                // Skip React hooks (functions starting with 'use')
-                if (node.id &&
-                    node.id.type === 'Identifier' &&
-                    node.id.name.startsWith('use')) {
-                    return;
+                // For functions with exactly one parameter, check if it's passing through null/undefined
+                if (node.params.length === 1) {
+                    checkFunctionBody(node.body, node.params[0], context);
+                }
+                else {
+                    // For functions with multiple parameters, check for early returns without arguments
+                    checkFunctionBodyForEarlyReturns(node.body, node.params, context);
                 }
-                checkFunctionBody(node.body, node.params[0], context);
             },
             ArrowFunctionExpression(node) {
-                // Only apply to arrow functions with exactly one parameter
-                if (node.params.length !== 1) {
-                    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
                 if (node.body.type === 'BlockStatement') {
-                    checkFunctionBody(node.body, node.params[0], context);
+                    if (node.params.length === 1) {
+                        checkFunctionBody(node.body, node.params[0], context);
+                    }
+                    else {
+                        // For functions with multiple parameters, check for early returns without arguments
+                        checkFunctionBodyForEarlyReturns(node.body, node.params, context);
+                    }
                 }
-                else {
-                    // For arrow functions with expression body (implicit return)
+                else if (node.params.length === 1) {
+                    // For arrow functions with expression body (implicit return) and one parameter
                     checkImplicitReturn(node, context);
                 }
             },
             FunctionExpression(node) {
-                // Only apply to functions with exactly one parameter
-                if (node.params.length !== 1) {
+                if (shouldSkipFunction(node)) {
                     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')) {
-                    return;
+                // For functions with exactly one parameter, check if it's passing through null/undefined
+                if (node.params.length === 1) {
+                    checkFunctionBody(node.body, node.params[0], context);
+                }
+                else {
+                    // For functions with multiple parameters, check for early returns without arguments
+                    checkFunctionBodyForEarlyReturns(node.body, node.params, context);
                 }
-                checkFunctionBody(node.body, node.params[0], context);
             },
         };
     },
@@ -66,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: [],
@@ -106,6 +102,7 @@ function checkFunctionBody(body, param, context) {
                                 context.report({
                                     node: statement,
                                     messageId: 'unexpected',
+                                    data: { paramName },
                                 });
                             }
                             return;
@@ -122,6 +119,7 @@ function checkFunctionBody(body, param, context) {
                         context.report({
                             node: statement,
                             messageId: 'unexpected',
+                            data: { paramName },
                         });
                     }
                     return;
@@ -136,18 +134,81 @@ function checkFunctionBody(body, param, context) {
 function checkForTransformation(body, paramName) {
     if (!paramName)
         return false;
-    // Look for return statements that call functions with the parameter
+    // Look for return statements or other statements that use the parameter in a transformation
     for (const statement of body.body) {
         if (statement.type === 'ReturnStatement' && statement.argument) {
-            // Check for return transformData(data) pattern
-            if (statement.argument.type === 'CallExpression' &&
-                statement.argument.arguments.some(arg => arg.type === 'Identifier' && arg.name === paramName)) {
+            // Check for various transformation patterns
+            if (containsParameterTransformation(statement.argument, paramName)) {
+                return true;
+            }
+        }
+        // Check for other statements that might contain transformations (like for loops with yield)
+        if (statement.type === 'ForStatement' ||
+            statement.type === 'ForInStatement' ||
+            statement.type === 'ForOfStatement') {
+            if (containsTransformationInStatement(statement, paramName)) {
                 return true;
             }
         }
     }
     return false;
 }
+/**
+ * Check if a statement contains a transformation of the parameter
+ */
+function containsTransformationInStatement(statement, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_paramName) {
+    // For generator functions, check if there are yield expressions with external function calls
+    if (statement.type === 'ForOfStatement' &&
+        statement.body.type === 'BlockStatement') {
+        for (const stmt of statement.body.body) {
+            if (stmt.type === 'ExpressionStatement' &&
+                stmt.expression.type === 'YieldExpression' &&
+                stmt.expression.argument &&
+                stmt.expression.argument.type === 'CallExpression' &&
+                stmt.expression.argument.callee.type === 'Identifier') {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Check if an expression contains a transformation of the parameter
+ * A transformation is considered to be calling external functions with the parameter,
+ * not just calling methods on the parameter itself.
+ */
+function containsParameterTransformation(node, paramName) {
+    // Check for direct function calls with the parameter: transformData(data)
+    // This is considered a transformation because it's calling an external function
+    if (node.type === 'CallExpression' &&
+        node.callee.type === 'Identifier' && // External function call
+        node.arguments.some((arg) => arg.type === 'Identifier' && arg.name === paramName)) {
+        return true;
+    }
+    // Check for Object.* method calls: Object.keys(data), Object.values(data), Object.entries(data)
+    if (node.type === 'CallExpression' &&
+        node.callee.type === 'MemberExpression' &&
+        node.callee.object.type === 'Identifier' &&
+        node.callee.object.name === 'Object' &&
+        node.arguments.some((arg) => arg.type === 'Identifier' && arg.name === paramName)) {
+        return true;
+    }
+    // Check for chained operations that start with external functions: Object.entries(rounds).reduce(...).sort(...)
+    if (node.type === 'CallExpression' &&
+        node.callee.type === 'MemberExpression' &&
+        node.callee.object.type === 'CallExpression' &&
+        node.callee.object.callee.type === 'MemberExpression' &&
+        node.callee.object.callee.object.type === 'Identifier' &&
+        node.callee.object.callee.object.name === 'Object' &&
+        node.callee.object.arguments.some((arg) => arg.type === 'Identifier' && arg.name === paramName)) {
+        return true;
+    }
+    // Method calls on the parameter itself (like data.process(), items.filter())
+    // are NOT considered transformations for the purpose of this rule
+    return false;
+}
 /**
  * Check arrow functions with expression bodies (implicit returns)
  */
@@ -171,6 +232,7 @@ function checkImplicitReturn(node, context) {
             context.report({
                 node,
                 messageId: 'unexpected',
+                data: { paramName },
             });
         }
     }
@@ -181,6 +243,7 @@ function checkImplicitReturn(node, context) {
             context.report({
                 node,
                 messageId: 'unexpected',
+                data: { paramName },
             });
         }
     }
@@ -189,6 +252,7 @@ function checkImplicitReturn(node, context) {
         context.report({
             node,
             messageId: 'unexpected',
+            data: { paramName },
         });
     }
 }
@@ -205,8 +269,10 @@ function isNullUndefinedCheck(node, paramName) {
     }
     // Check for param === null, param === undefined, etc.
     if (node.type === 'BinaryExpression' &&
-        (node.operator === '===' || node.operator === '==' ||
-            node.operator === '!==' || node.operator === '!=')) {
+        (node.operator === '===' ||
+            node.operator === '==' ||
+            node.operator === '!==' ||
+            node.operator === '!=')) {
         const left = node.left;
         const right = node.right;
         // param === null/undefined
@@ -224,8 +290,7 @@ function isNullUndefinedCheck(node, paramName) {
         }
     }
     // Check for param === null || param === undefined
-    if (node.type === 'LogicalExpression' &&
-        node.operator === '||') {
+    if (node.type === 'LogicalExpression' && node.operator === '||') {
         return (isNullUndefinedCheck(node.left, paramName) ||
             isNullUndefinedCheck(node.right, paramName));
     }
@@ -251,4 +316,116 @@ function isParameterReference(node, paramName) {
         return false;
     return node.type === 'Identifier' && node.name === paramName;
 }
+/**
+ * Check function body for early returns without arguments (implicit undefined)
+ * based on parameter null/undefined checks
+ */
+function checkFunctionBodyForEarlyReturns(body, params, context) {
+    // Get parameter names
+    const paramNames = params
+        .map((param) => {
+        if (param.type === 'Identifier') {
+            return param.name;
+        }
+        else if (param.type === 'AssignmentPattern' &&
+            param.left.type === 'Identifier') {
+            return param.left.name;
+        }
+        return null;
+    })
+        .filter((name) => name !== null);
+    if (paramNames.length === 0)
+        return;
+    // Look for early returns without arguments based on parameter checks
+    for (const statement of body.body) {
+        if (statement.type === 'IfStatement') {
+            const test = statement.test;
+            // Check if the test is checking any parameter for null/undefined
+            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) {
+                        if (consequentStmt.type === 'ReturnStatement' &&
+                            (!consequentStmt.argument ||
+                                isNullOrUndefinedLiteral(consequentStmt.argument))) {
+                            // Check if there's a transformation in the function
+                            const hasTransformation = paramNames.some((paramName) => checkForTransformation(body, paramName));
+                            if (!hasTransformation) {
+                                context.report({
+                                    node: statement,
+                                    messageId: 'unexpected',
+                                    data: { paramName: matchedParam },
+                                });
+                            }
+                            return;
+                        }
+                    }
+                }
+                // Check if the consequent is a direct return statement without an argument
+                else if (statement.consequent.type === 'ReturnStatement' &&
+                    (!statement.consequent.argument ||
+                        isNullOrUndefinedLiteral(statement.consequent.argument))) {
+                    // Check if there's a transformation in the function
+                    const hasTransformation = paramNames.some((paramName) => checkForTransformation(body, paramName));
+                    if (!hasTransformation) {
+                        context.report({
+                            node: statement,
+                            messageId: 'unexpected',
+                            data: { paramName: matchedParam },
+                        });
+                    }
+                    return;
+                }
+            }
+        }
+    }
+}
+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 {};