@blumintinc/eslint-plugin-blumint 1.20.98 → 1.20.99

package/lib/index.js

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

package/lib/rules/enforce-memoize-async.js

@@ -43,6 +43,46 @@ function bindsMemoize(variable) {
                 ALLOWED_MEMOIZE_MODULES.has(String(declaration.source.value)));
         }));
 }
+/**
+ * `jest.mock` hoists its module factory above the file's imports;
+ * `doMock`/`setMock` register a factory of the same shape at call time. The
+ * hoist rejects a factory that reads any out-of-scope binding whose name does
+ * not begin with `mock`, which is what puts a module-scope `Memoize` binding —
+ * injected or already present — out of reach inside one.
+ */
+const MOCK_REGISTRARS = new Set(['mock', 'doMock', 'setMock']);
+/** Whether the call registers a module factory with `jest`. */
+function isMockRegistrarCall(node) {
+    const { callee } = node;
+    if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression || callee.computed) {
+        return false;
+    }
+    const { object, property } = callee;
+    return (object.type === utils_1.AST_NODE_TYPES.Identifier &&
+        object.name === 'jest' &&
+        property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        MOCK_REGISTRARS.has(property.name));
+}
+/**
+ * Whether the node sits inside the factory a jest registrar hoists — the second
+ * argument of the call. The module specifier that precedes it is evaluated in
+ * place and keeps its access to the file's imports, so only the factory subtree
+ * is out of reach.
+ */
+function isInsideMockFactory(node) {
+    let child = node;
+    let parent = node.parent;
+    while (parent) {
+        if (parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+            parent.arguments[1] === child &&
+            isMockRegistrarCall(parent)) {
+            return true;
+        }
+        child = parent;
+        parent = parent.parent;
+    }
+    return false;
+}
 /**
  * Whether a declared return type annotation promises no value: `void` or
  * `Promise<void>`.
@@ -297,6 +337,20 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                         if (isReportSuppressed(node)) {
                             return null;
                         }
+                        // A jest registrar's factory is hoisted above every import in the
+                        // file, so the decorator emitted inside one names a binding that
+                        // does not exist yet: the hoist admits only globals and
+                        // `mock`-prefixed bindings, and rejects the module at transform
+                        // time otherwise, taking the whole suite down with it. That holds
+                        // for an alias or namespace decorator too — those read a
+                        // module-scope import the factory cannot reach either. Declining
+                        // here, ahead of the import carrier claim below, leaves the import
+                        // to a violation that does fix, and leaves the report standing so
+                        // the author reaches for a remedy the factory can hold, such as
+                        // decorating the real class the mock stands in for.
+                        if (isInsideMockFactory(node)) {
+                            return null;
+                        }
                         const fixes = [];
                         const sourceCode = context.sourceCode;
                         // Determine which identifier to use for the decorator

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

@@ -20,69 +20,38 @@ function isKnownHookCallee(callee, knownHooks, assumeAllUseAreMemoized) {
     }
     return false;
 }
-function isPreventDefaultCall(stmt, params) {
+const EVENT_SUPPRESSION_METHODS = new Set([
+    'preventDefault',
+    'stopPropagation',
+    'stopImmediatePropagation',
+]);
+/**
+ * A wrapper that suppresses the event carries behaviour the rule's own remedy
+ * cannot preserve: passing the memoized callback directly both drops the
+ * suppression call and hands React's event to a callback that took no
+ * 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.
+ */
+function isEventSuppressionCall(stmt) {
     if (stmt.type !== utils_1.AST_NODE_TYPES.ExpressionStatement)
         return false;
-    const expr = stmt.expression;
-    if (expr.type !== utils_1.AST_NODE_TYPES.CallExpression)
+    const expr = unwrapChainExpression(stmt.expression);
+    if (!expr || expr.type !== utils_1.AST_NODE_TYPES.CallExpression)
         return false;
-    if (expr.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression)
+    const callee = unwrapChainExpression(expr.callee);
+    if (!callee)
         return false;
-    const member = expr.callee;
-    if (member.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-        params.includes(member.object.name) &&
-        member.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-        (member.property.name === 'preventDefault' ||
-            member.property.name === 'stopPropagation' ||
-            member.property.name === 'stopImmediatePropagation')) {
-        return true;
+    // A destructured `({ preventDefault })` reaches the method without a receiver.
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return EVENT_SUPPRESSION_METHODS.has(callee.name);
     }
-    return false;
-}
-function getParams(node) {
-    const names = new Set();
-    for (const p of node.params) {
-        if (p.type === utils_1.AST_NODE_TYPES.Identifier) {
-            names.add(p.name);
-        }
-        else if (p.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
-            for (const prop of p.properties) {
-                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
-                    // Collect bound identifier names (aliases/defaults)
-                    if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        names.add(prop.value.name);
-                    }
-                    else if (prop.value.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
-                        prop.value.left.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        names.add(prop.value.left.name);
-                    }
-                }
-                else if (prop.type === utils_1.AST_NODE_TYPES.RestElement) {
-                    if (prop.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        names.add(prop.argument.name);
-                    }
-                }
-            }
-        }
-        else if (p.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
-            for (const element of p.elements) {
-                if (!element)
-                    continue;
-                if (element.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    names.add(element.name);
-                }
-                else if (element.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
-                    element.left.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    names.add(element.left.name);
-                }
-                else if (element.type === utils_1.AST_NODE_TYPES.RestElement &&
-                    element.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    names.add(element.argument.name);
-                }
-            }
-        }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return EVENT_SUPPRESSION_METHODS.has(callee.property.name);
     }
-    return Array.from(names);
+    return false;
 }
 function isIdentifierOrMemberOn(obj, nameSet) {
     if (obj.type === utils_1.AST_NODE_TYPES.Identifier) {
@@ -224,7 +193,6 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                         (unwrappedArg.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
                             unwrappedArg.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
                         const fn = unwrappedArg;
-                        const params = getParams(fn);
                         // Handle implicit return: () => memoizedFn()
                         if (fn.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
                             fn.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
@@ -263,21 +231,25 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                             }
                             return;
                         }
-                        // Handle block body: () => { [maybe e.preventDefault()]; return memoizedFn(); }
+                        // Handle block body: () => { return memoizedFn(); }
                         if (fn.body && fn.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
                             const stmts = fn.body.body.filter(Boolean);
-                            if (stmts.length >= 1 && stmts.length <= 2) {
-                                let idx = 0;
-                                if (stmts.length === 2 &&
-                                    isPreventDefaultCall(stmts[0], params)) {
-                                    idx = 1;
-                                }
-                                const last = stmts[idx];
-                                if (last.type === utils_1.AST_NODE_TYPES.ReturnStatement ||
-                                    last.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
-                                    const expr = last.type === utils_1.AST_NODE_TYPES.ReturnStatement
-                                        ? last.argument
-                                        : last.expression;
+                            // 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))
+                                return;
+                            // Exactly one statement. A wrapper that sequences a second call is
+                            // doing work the delegate alone does not, so collapsing it would
+                            // drop that call — only the branch's own statement is ever read,
+                            // so a wider count silently discards whatever it did not look at.
+                            if (stmts.length === 1) {
+                                const first = stmts[0];
+                                if (first.type === utils_1.AST_NODE_TYPES.ReturnStatement ||
+                                    first.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+                                    const expr = first.type === utils_1.AST_NODE_TYPES.ReturnStatement
+                                        ? first.argument
+                                        : first.expression;
                                     if (expr && expr.type === utils_1.AST_NODE_TYPES.CallExpression) {
                                         const callee = unwrapChainExpression(expr.callee);
                                         const isHookProp = callee &&

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,27 @@
 [
+  {
+    "version": "1.20.99",
+    "date": "2026-08-04T12:38:33.934Z",
+    "rules": [
+      {
+        "name": "enforce-memoize-async",
+        "changeType": "fix",
+        "issues": [
+          1697
+        ],
+        "summary": "decline the decorator inside a jest.mock factory (closes #1697)"
+      },
+      {
+        "name": "no-redundant-usecallback-wrapper",
+        "changeType": "fix",
+        "issues": [
+          1696,
+          1699
+        ],
+        "summary": "require a single-statement body before collapsing (closes #1699); treat event suppression as disqualifying, not skippable (closes #1696)"
+      }
+    ]
+  },
   {
     "version": "1.20.98",
     "date": "2026-08-04T10:58:56.821Z",