@blumintinc/eslint-plugin-blumint 1.20.121 → 1.20.122

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.121',
+        version: '1.20.122',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/no-redundant-usecallback-wrapper.js

@@ -103,11 +103,17 @@ const EVENT_SUPPRESSION_METHODS = new Set([
  * arguments. Such a wrapper is not redundant, so the receiver is deliberately
  * unconstrained — deleting `x.preventDefault()` changes behaviour whether `x`
  * is a parameter, a captured value or a nested member.
+ *
+ * The question is asked of the call itself rather than of a statement, because
+ * the behaviour that makes the wrapper load-bearing is identical whether the
+ * author spelled it as a concise arrow body, a `return` or an expression
+ * statement — and a predicate that recognizes only one of those spellings
+ * reports the other two while prescribing a remedy that does not exist.
  */
-function isEventSuppressionCall(stmt) {
-    if (stmt.type !== utils_1.AST_NODE_TYPES.ExpressionStatement)
+function isEventSuppressionCall(expression) {
+    if (!expression)
         return false;
-    const expr = unwrapChainExpression(stmt.expression);
+    const expr = unwrapChainExpression(expression);
     if (!expr || expr.type !== utils_1.AST_NODE_TYPES.CallExpression)
         return false;
     const callee = unwrapChainExpression(expr.callee);
@@ -124,6 +130,19 @@ function isEventSuppressionCall(stmt) {
     }
     return false;
 }
+/**
+ * The statement carrying a wrapper's effective call, so the suppression test
+ * reads the same expression from either statement kind.
+ */
+function isEventSuppressionStatement(stmt) {
+    if (stmt.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+        return isEventSuppressionCall(stmt.expression);
+    }
+    if (stmt.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+        return isEventSuppressionCall(stmt.argument);
+    }
+    return false;
+}
 function isIdentifierOrMemberOn(obj, nameSet) {
     if (obj.type === utils_1.AST_NODE_TYPES.Identifier) {
         return nameSet.has(obj.name);
@@ -379,6 +398,11 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                         // Handle implicit return: () => memoizedFn()
                         if (fn.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
                             fn.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                            // An event-suppression call disqualifies the wrapper outright: no
+                            // spelling of "pass the callback directly" keeps it, so reporting
+                            // here would prescribe a remedy that does not exist.
+                            if (isEventSuppressionCall(fn.body))
+                                return;
                             const bodyExpr = unwrapChainExpression(fn.body);
                             if (bodyExpr && bodyExpr.type === utils_1.AST_NODE_TYPES.CallExpression) {
                                 const callee = unwrapChainExpression(bodyExpr.callee);
@@ -426,8 +450,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                             const stmts = fn.body.body.filter(Boolean);
                             // An event-suppression call disqualifies the wrapper outright: no
                             // spelling of "pass the callback directly" keeps it, so reporting
-                            // here would prescribe a remedy that does not exist.
-                            if (stmts.some(isEventSuppressionCall))
+                            // here would prescribe a remedy that does not exist. Any statement
+                            // carrying one is enough — the call is load-bearing wherever in
+                            // the body it sits.
+                            if (stmts.some(isEventSuppressionStatement))
                                 return;
                             // Exactly one statement. A wrapper that sequences a second call is
                             // doing work the delegate alone does not, so collapsing it would

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.20.121",
+  "version": "1.20.122",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.122",
+    "date": "2026-08-06T11:06:53.595Z",
+    "rules": [
+      {
+        "name": "no-redundant-usecallback-wrapper",
+        "changeType": "fix",
+        "issues": [
+          1796
+        ],
+        "summary": "exempt a suppression wrapper in every body spelling (closes #1796)"
+      }
+    ]
+  },
   {
     "version": "1.20.121",
     "date": "2026-08-06T10:37:08.150Z",