@blumintinc/eslint-plugin-blumint 1.20.121 → 1.20.123

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.123',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-mock-firestore.js

@@ -8,6 +8,36 @@ const FIRESTORE_PATHS = [
     'firebase-admin',
     'firebase-admin/firestore',
 ];
+/**
+ * A `jest.mock` factory produces the same module shape whether it is written as
+ * a concise arrow, a block-bodied arrow, or a `function` expression. Matching
+ * the factory argument itself would only ever see the concise arrow, letting an
+ * identical mock evade the rule on a body-form choice alone. Resolving to the
+ * produced object keeps every spelling on one matching path.
+ *
+ * A body with more than a lone `return` is deliberately unresolved: the object
+ * reaching the caller can no longer be read off a single expression.
+ */
+const resolveFactoryReturn = (factory) => {
+    if (!factory ||
+        (factory.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+            factory.type !== utils_1.AST_NODE_TYPES.FunctionExpression)) {
+        return undefined;
+    }
+    // A concise arrow body is the produced expression itself. Parentheses around
+    // an object body are not part of the AST, so the node is matched directly.
+    if (factory.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+        return factory.body;
+    }
+    const statements = factory.body.body;
+    if (statements.length !== 1) {
+        return undefined;
+    }
+    const [statement] = statements;
+    return statement.type === utils_1.AST_NODE_TYPES.ReturnStatement
+        ? statement.argument ?? undefined
+        : undefined;
+};
 exports.enforceFirestoreMock = (0, createRule_1.createRule)({
     name: 'enforce-mock-firestore',
     meta: {
@@ -39,21 +69,18 @@ exports.enforceFirestoreMock = (0, createRule_1.createRule)({
                         typeof node.arguments[0].value === 'string' &&
                         node.arguments[0].value?.includes(path))) {
                     // Check if the mock includes Firestore-related properties
-                    const mockFn = node.arguments[1];
-                    if (mockFn &&
-                        mockFn.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-                        const returnStmt = mockFn.body;
-                        if (returnStmt.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                            returnStmt.properties.some((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
-                                prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                (prop.key.name === 'db' ||
-                                    prop.key.name === 'firestore' ||
-                                    prop.key.name === 'getFirestore'))) {
-                            context.report({
-                                node,
-                                messageId: 'noManualFirestoreMock',
-                            });
-                        }
+                    const mockedModule = resolveFactoryReturn(node.arguments[1]);
+                    if (mockedModule &&
+                        mockedModule.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                        mockedModule.properties.some((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            (prop.key.name === 'db' ||
+                                prop.key.name === 'firestore' ||
+                                prop.key.name === 'getFirestore'))) {
+                        context.report({
+                            node,
+                            messageId: 'noManualFirestoreMock',
+                        });
                     }
                 }
             },

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.123",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.123",
+    "date": "2026-08-06T11:53:46.588Z",
+    "rules": [
+      {
+        "name": "enforce-mock-firestore",
+        "changeType": "fix",
+        "issues": [
+          1798
+        ],
+        "summary": "resolve the jest.mock factory's returned object in every body form (closes #1798)"
+      }
+    ]
+  },
+  {
+    "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",