@blumintinc/eslint-plugin-blumint 1.20.89 → 1.20.91

package/lib/index.js

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

package/lib/rules/enforce-assert-safe-object-key.js

@@ -78,6 +78,46 @@ function nearestManifestDeclaresModule(startDir) {
         }
     }
 }
+/**
+ * `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 the injected `assertSafe` import
+ * 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;
+}
 /** Names that read as a positional sequence rather than a keyed record. */
 const ARRAY_LIKE_NAME = /^(array|arr|items|elements|list|collection|data)s?$/i;
 /**
@@ -365,6 +405,18 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                 if (isReportSuppressed(node)) {
                     return null;
                 }
+                // A jest registrar's factory is hoisted above every import in the
+                // file, so the injected `import { assertSafe }` binds too late for
+                // the emitted call: the hoist allows a factory to read only globals
+                // and `mock`-prefixed bindings, and rejects the module at transform
+                // time otherwise, taking the whole suite down with it. Declining —
+                // and leaving the import unclaimed for a violation that does fix —
+                // keeps the report standing so the author reaches for a remedy the
+                // factory can hold, such as `jest.requireActual` inside it or a
+                // `mock`-prefixed import alias.
+                if (isInsideMockFactory(node)) {
+                    return null;
+                }
                 // Resolve `assertSafe` through the scope chain at the fixed node. A
                 // binding that is not the helper import breaks the edit two ways: the
                 // injected import collides with a module-scope declaration (TS2440,

package/lib/rules/prefer-fragment-component.js

@@ -59,6 +59,52 @@ function bindsReactFragment(variable) {
                 declaration.source.value === REACT_MODULE);
         }));
 }
+/**
+ * `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 the injected `Fragment` import out
+ * of reach inside one: the module fails at transform time
+ * (`Invalid variable access: Fragment`) and takes the whole suite down with it.
+ * The shorthand `<>` the rule rewrites away is the spelling that works there.
+ *
+ * The report still fires, because remedies the factory can hold exist —
+ * `const { Fragment } = jest.requireActual('react')` inside it, or a
+ * `mock`-prefixed import alias — and only the fix is withheld.
+ */
+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;
+}
 exports.preferFragmentComponent = (0, createRule_1.createRule)({
     name: 'prefer-fragment-component',
     meta: {
@@ -227,6 +273,13 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                             if (isReportSuppressed(node)) {
                                 return null;
                             }
+                            // A hoisted jest factory cannot reach the injected import, so
+                            // the rewrite is withheld inside one. Checking the inner
+                            // fragment covers the outer React.Fragment as well, since a
+                            // parent of a node in the factory is in the factory too.
+                            if (isInsideMockFactory(node)) {
+                                return null;
+                            }
                             // Both tags are rewritten to the same bare name, so resolving at
                             // the inner fragment — the deeper of the two scopes — covers the
                             // outer one too. Every bail precedes the latch so a withheld edit
@@ -294,6 +347,11 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                         if (isReportSuppressed(node)) {
                             return null;
                         }
+                        // A hoisted jest factory cannot reach the injected import, so the
+                        // rewrite is withheld inside one.
+                        if (isInsideMockFactory(node)) {
+                            return null;
+                        }
                         // Every bail precedes the latch so a withheld edit cannot make a
                         // later fix believe the import is already handled.
                         if (!resolvesToReactFragment(node)) {
@@ -350,6 +408,11 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                             if (isReportSuppressed(node.name)) {
                                 return null;
                             }
+                            // A hoisted jest factory cannot reach the injected import, so
+                            // the rewrite is withheld inside one.
+                            if (isInsideMockFactory(node)) {
+                                return null;
+                            }
                             // Every bail precedes the latch so a withheld edit cannot make a
                             // later fix believe the import is already handled.
                             if (!resolvesToReactFragment(node)) {
@@ -391,6 +454,11 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                         if (isReportSuppressed(node.name)) {
                             return null;
                         }
+                        // A hoisted jest factory cannot reach the injected import, so the
+                        // rewrite is withheld inside one.
+                        if (isInsideMockFactory(node)) {
+                            return null;
+                        }
                         // Every bail precedes the latch so a withheld edit cannot make a
                         // later fix believe the import is already handled.
                         if (!resolvesToReactFragment(node)) {

package/lib/rules/prefer-use-deep-compare-memo.js

@@ -5,6 +5,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const importInsertion_1 = require("../utils/importInsertion");
+const importRemoval_1 = require("../utils/importRemoval");
 const DEEP_COMPARE_MODULE = '@blumintinc/use-deep-compare';
 const DEEP_COMPARE_HOOK = 'useDeepCompareMemo';
 // Consider these as memoizing hooks producing stable references
@@ -218,49 +219,6 @@ function ensureDeepCompareImportFixes(context, fixer) {
         (0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, (0, importInsertion_1.importAnchorLineStart)(sourceCode, anchor), importText),
     ];
 }
-function findVariableInScope(scope, name) {
-    if (!scope)
-        return null;
-    const found = scope.variables?.find((v) => v.name === name);
-    if (found)
-        return found;
-    if (Array.isArray(scope.childScopes)) {
-        for (const child of scope.childScopes) {
-            const v = findVariableInScope(child, name);
-            if (v)
-                return v;
-        }
-    }
-    return null;
-}
-function isIdentifierReferenced(sourceCode, name) {
-    const scope = sourceCode.scopeManager?.globalScope;
-    if (!scope)
-        return true;
-    const variable = findVariableInScope(scope, name);
-    if (!variable)
-        return false;
-    return variable.references.some((ref) => ref.identifier && ref.identifier.name === name);
-}
-function removeImportSpecifierFixes(sourceCode, fixer, importDecl, specifier) {
-    const fixes = [];
-    if (importDecl.specifiers.length === 1) {
-        fixes.push(fixer.remove(importDecl));
-        return fixes;
-    }
-    const tokenAfter = sourceCode.getTokenAfter(specifier);
-    const tokenBefore = sourceCode.getTokenBefore(specifier);
-    if (tokenAfter && tokenAfter.value === ',') {
-        fixes.push(fixer.removeRange([specifier.range[0], tokenAfter.range[1]]));
-    }
-    else if (tokenBefore && tokenBefore.value === ',') {
-        fixes.push(fixer.removeRange([tokenBefore.range[0], specifier.range[1]]));
-    }
-    else {
-        fixes.push(fixer.remove(specifier));
-    }
-    return fixes;
-}
 function isImportedIdentifier(context, name) {
     const sourceCode = context.sourceCode;
     const program = sourceCode.ast;
@@ -436,6 +394,28 @@ exports.preferUseDeepCompareMemo = (0, createRule_1.createRule)({
                             !bindsHookImport(existing, findDeepCompareMemoImport(context.sourceCode.ast))) {
                             return null;
                         }
+                        // The callee is the text this fix deletes, so it is also the text
+                        // whatever carried the hook stops being read from: `useMemo` for a
+                        // bare call, `React` for a member call. A binding left with no
+                        // reference at all is unbound here, in this same fix — stripping
+                        // its last use and keeping the declaration trades this rule's
+                        // report for an unused-import one, and nothing re-reports that debt
+                        // once the rewrite has resolved the original violation.
+                        //
+                        // Orphanhood is judged against this one callee's removal and the
+                        // file as it stands. A second `useMemo` call site keeps the
+                        // specifier, even one this rule also reports: that sibling may be
+                        // `eslint-disable`d (suppression is applied after a rule emits its
+                        // reports, so its fix never runs) or lose its fix to a conflict, and
+                        // either way the surviving call would spell a name nothing binds. A
+                        // later pass, reading a source where the sibling is already
+                        // converted, finds the specifier orphaned and removes it then.
+                        const importRemoval = (0, importRemoval_1.planOrphanedImportRemoval)(context.sourceCode, [node.callee.range]);
+                        // No plan means a binding is orphaned yet cannot be unbound safely,
+                        // so the rewrite stays too: the report without a fixer is the lesser
+                        // damage.
+                        if (!importRemoval)
+                            return null;
                         const fixes = [];
                         // Replace callee
                         if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
@@ -446,26 +426,7 @@ exports.preferUseDeepCompareMemo = (0, createRule_1.createRule)({
                         }
                         // Ensure import exists
                         fixes.push(...ensureDeepCompareImportFixes(context, fixer));
-                        // Clean up now-unused React/useMemo imports if safe
-                        const sourceCode = context.sourceCode;
-                        const program = sourceCode.ast;
-                        const reactImport = program.body.find((n) => n.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
-                            n.source.value === 'react');
-                        if (reactImport) {
-                            // remove named useMemo if unused
-                            const useMemoSpec = reactImport.specifiers.find((s) => s.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                                s.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                s.imported.name === 'useMemo');
-                            if (useMemoSpec &&
-                                !isIdentifierReferenced(sourceCode, useMemoSpec.local.name)) {
-                                fixes.push(...removeImportSpecifierFixes(sourceCode, fixer, reactImport, useMemoSpec));
-                            }
-                            const defaultSpec = reactImport.specifiers.find((s) => s.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
-                            if (defaultSpec &&
-                                !isIdentifierReferenced(sourceCode, defaultSpec.local.name)) {
-                                fixes.push(...removeImportSpecifierFixes(sourceCode, fixer, reactImport, defaultSpec));
-                            }
-                        }
+                        fixes.push(...importRemoval.map((range) => fixer.removeRange([range[0], range[1]])));
                         return fixes;
                     },
                 });

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.20.91",
+    "date": "2026-08-03T15:15:42.831Z",
+    "rules": [
+      {
+        "name": "prefer-use-deep-compare-memo",
+        "changeType": "fix",
+        "issues": [
+          1661
+        ],
+        "summary": "unbind the orphaned useMemo import (closes #1661)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.90",
+    "date": "2026-08-03T13:37:18.271Z",
+    "rules": [
+      {
+        "name": "enforce-assert-safe-object-key",
+        "changeType": "fix",
+        "issues": [
+          1659
+        ],
+        "summary": "decline the fix inside a jest mock factory (closes #1659)"
+      },
+      {
+        "name": "prefer-fragment-component",
+        "changeType": "fix",
+        "issues": [
+          1660
+        ],
+        "summary": "decline the fix inside a jest mock factory (closes #1660)"
+      }
+    ]
+  },
   {
     "version": "1.20.89",
     "date": "2026-08-03T12:31:01.823Z",