@blumintinc/eslint-plugin-blumint 1.20.89 → 1.20.90

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.90',
     },
     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/package.json

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

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "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",